void find_match(int nd /* data size */,
float* mm /* match [nd] */,
float* dd /* data [nd] */,
sf_filter aa /* estimated filter */,
int niter /* number of iterations */,
float eps /* regularization parameter */)
/*< find matched filter >*/
{
int id, nh2;
float *dd_pad=NULL,*tmp=NULL;
float eps_S=0.0;
bool CG = true;
nh2 = (aa->nh-1) / 2;
dd_pad = sf_floatalloc(nd+aa->nh-1);
for (id=0;id<(nd+aa->nh-1);id++) {
if (CG==true)
dd_pad[id] = 0.0;
else {
dd_pad[id] = eps;
if (id<nd) mm[id]+=eps;
}
}
for (id=0;id<nd;id++)
dd_pad[id+nh2] += dd[id];
if (CG) {
/* solution using preconditioned CG */ //FIXME: still memory leaks in sf_cdstep (sf_list) not affordable with huge datasets
helix_tcaf_init(nd, mm, aa);
sf_cdstep_init();
sf_solver_prec(helix_tcaf_lop, sf_cdstep, sf_copy_lop, aa->nh,aa->nh, nd+aa->nh-1, aa->flt, dd_pad,
niter*3, eps, "x0", aa->flt, "verb",false,"end");
sf_cdstep_close();
}
else {
/* solution using shaping CG with S = (1+eps^2)^(-1) I*/
eps_S = 1.0 / (1.0+eps);
tmp = sf_floatalloc(aa->nh);
helix_tcaf_init(nd,mm, aa);
copy_scaled_init(eps_S);
sf_conjgrad_init(aa->nh, aa->nh, nd+aa->nh-1, nd+aa->nh-1, 1.0, 1.e-8, false, false);
sf_conjgrad(NULL,helix_tcaf_lop,copy_scaled_lop,
tmp,aa->flt,dd_pad,3*niter);
sf_conjgrad_close();
free(tmp);
free(dd_pad);
}
}
void div2_init(int n1, int n2 /* data dimensions */,
float f1, float f2 /* smoothing */,
int niter1 /* number of iterations */,
bool gauss1 /* if exact gaussian */,
bool verb /* verbosity flag */)
/*< initialize >*/
{
n = n1*n2;
niter = niter1;
gauss = gauss1;
if (gauss) {
gauss2_init(n1,n2,f1,f2);
} else {
sf_triangle2_init((int) f1, (int) f2, n1, n2, 1);
}
sf_conjgrad_init(n, n, n, n, 1., 1.e-6, verb, false);
p = sf_floatalloc (n);
}
void nmultidivn_init(int nw /* number of components */, \
int ndim /* number of dimensions */,
int n /* data size */,
int *ndat /* data dimensions [ndim] */,
int *nbox /* smoothing radius [nw] */,
float* den /* denominator [nw*nd] */,
bool verb /* verbosity flag */)
/*< initialize >*/
{
int n2;
n2 = n*nw;
ntrianglen2_init(nw,n,ndat[0],nbox);
sf_conjgrad_init(n2, n2, n, n, 1., 1.e-6, verb, false);
p = sf_floatalloc (n2);
sf_weight2_init(nw,n,den);
}
void sf_multidivn_init(int nw /* number of components */,
int ndim /* number of dimensions */,
int n /* data size */,
int *ndat /* data dimensions [ndim] */,
int *nbox /* smoothing radius [ndim] */,
float* den /* denominator [nw*nd] */,
sf_filter aa /* data filter */,
bool verb /* verbosity flag */)
/*< initialize >*/
{
int n2;
n2 = n*nw;
sf_trianglen_init(ndim, nbox, ndat);
sf_repeat_init(n,nw,sf_trianglen_lop);
sf_conjgrad_init(n2, n2, n, n, 1., 1.e-6, verb, false);
p = sf_floatalloc (n2);
sf_weight2_init(nw,n,den);
prec = (bool) (NULL != aa);
if (prec) sf_helicon_init(aa);
}
int main(int argc, char* argv[])
{
int i, niter, n1, n2, n12, i3, n3, rect1, rect2, order;
float *mm, *dd, **pp, lam;
bool *known;
sf_file in, out, dip, mask;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
dip = sf_input("dip");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n12 = n1*n2;
n3 = sf_leftsize(in,2);
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
pp = sf_floatalloc2(n1,n2);
mm = sf_floatalloc(n12);
known = sf_boolalloc(n12);
if (NULL != sf_getstring ("mask")) {
mask = sf_input("mask");
dd = sf_floatalloc(n12);
} else {
mask = NULL;
dd = NULL;
}
if (!sf_getint("rect1",&rect1)) rect1=3;
if (!sf_getint("rect2",&rect2)) rect2=3;
/* smoothing radius */
pwdsl_init(n1,n2,order,rect1,rect2,0.01);
pwdsl_set(pp);
sf_mask_init(known);
for (i3=0; i3 < n3; i3++) {
sf_warning("slice %d of %d",i3+1,n3);
sf_floatread(mm,n12,in);
if (NULL != mask) {
sf_floatread(dd,n12,mask);
} else {
dd = mm;
}
/* figure out scaling and make known data mask */
lam = 0.;
for (i=0; i < n12; i++) {
if (dd[i] != 0.) {
known[i] = true;
lam += 1.;
} else {
known[i] = false;
}
}
lam = sqrtf(lam/n12);
/* read dip */
sf_floatread(pp[0],n12,dip);
sf_conjgrad_init(n12, n12, n12, n12, lam, 10*FLT_EPSILON, true, true);
sf_conjgrad(NULL,sf_mask_lop,pwdsl_lop,dd,mm,mm,niter);
sf_conjgrad_close();
sf_floatwrite (mm,n12,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
bool velocity, verb, shape;
int dim, i, j, n[3], rect[3], it, nt, order, nt0, nx0;
int iter, niter, iline, nline, cgiter, *f0, *m0=NULL;
float d[3], o[3], dt0, dx0, ot0, ox0, eps, tol, *p=NULL, *p0=NULL, thres;
float *vd, *vdt, *vdx, *s, *t0, *x0, *ds, *rhs, *rhs0, *rhs1=NULL, error0, error1, error, scale;
char key[6];
sf_file in, out, dix, t_0=NULL, x_0=NULL, f_0=NULL, grad=NULL, cost=NULL, mini=NULL, prec=NULL;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
/* read input dimension */
dim = sf_filedims(in,n);
nt = 1;
for (i=0; i < dim; i++) {
sprintf(key,"d%d",i+1);
if (!sf_histfloat(in,key,d+i)) sf_error("No %s= in input",key);
sprintf(key,"o%d",i+1);
if (!sf_histfloat(in,key,o+i)) o[i]=0.;
nt *= n[i];
}
if (dim < 3) {
n[2] = 1; d[2] = d[1]; o[2] = o[1];
}
/* read initial guess */
s = sf_floatalloc(nt);
sf_floatread(s,nt,in);
if (!sf_getbool("velocity",&velocity)) velocity=true;
/* y, input is velocity / n, slowness-squared */
if (velocity) {
for (it=0; it < nt; it++) {
s[it] = 1./s[it]*1./s[it];
}
}
/* read Dix velocity */
if (NULL == sf_getstring("dix")) sf_error("No Dix input dix=");
dix = sf_input("dix");
if(!sf_histint(dix,"n1",&nt0)) sf_error("No n1= in dix");
if(!sf_histint(dix,"n2",&nx0)) sf_error("No n2= in dix");
if(!sf_histfloat(dix,"d1",&dt0)) sf_error("No d1= in dix");
if(!sf_histfloat(dix,"d2",&dx0)) sf_error("No d2= in dix");
if(!sf_histfloat(dix,"o1",&ot0)) sf_error("No o1= in dix");
if(!sf_histfloat(dix,"o2",&ox0)) sf_error("No o2= in dix");
vd = sf_floatalloc(nt0*nx0);
sf_floatread(vd,nt0*nx0,dix);
sf_fileclose(dix);
/* Dix velocity derivative in t0 (2nd order FD) */
vdt = sf_floatalloc(nt0*nx0);
for (i=0; i < nt0; i++) {
for (j=0; j < nx0; j++) {
if (i == 0)
vdt[j*nt0+i] = (-vd[j*nt0+i+2]+4.*vd[j*nt0+i+1]-3.*vd[j*nt0+i])/(2.*dt0);
else if (i == nt0-1)
vdt[j*nt0+i] = (3.*vd[j*nt0+i]-4.*vd[j*nt0+i-1]+vd[j*nt0+i-2])/(2.*dt0);
else
vdt[j*nt0+i] = (vd[j*nt0+i+1]-vd[j*nt0+i-1])/(2.*dt0);
}
}
/* Dix velocity derivative in x0 (2nd order FD) */
vdx = sf_floatalloc(nt0*nx0);
for (j=0; j < nx0; j++) {
for (i=0; i < nt0; i++) {
if (j == 0)
vdx[j*nt0+i] = (-vd[(j+2)*nt0+i]+4.*vd[(j+1)*nt0+i]-3.*vd[j*nt0+i])/(2.*dx0);
else if (j == nx0-1)
vdx[j*nt0+i] = (3.*vd[j*nt0+i]-4.*vd[(j-1)*nt0+i]+vd[(j-2)*nt0+i])/(2.*dx0);
else
vdx[j*nt0+i] = (vd[(j+1)*nt0+i]-vd[(j-1)*nt0+i])/(2.*dx0);
}
}
if (!sf_getint("order",&order)) order=1;
/* fastmarch accuracy order */
if (!sf_getfloat("thres",&thres)) thres=10.;
/* thresholding for caustics */
if (!sf_getint("niter",&niter)) niter=1;
/* number of nonlinear updates */
if (!sf_getint("cgiter",&cgiter)) cgiter=200;
/* number of CG iterations */
if (!sf_getbool("shape",&shape)) shape=false;
/* regularization (default Tikhnov) */
if (!sf_getfloat("eps",&eps)) eps=0.1;
/* regularization parameter */
if (!sf_getint("nline",&nline)) nline=0;
/* maximum number of line search (default turned-off) */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
if (shape) {
if (!sf_getfloat("tol",&tol)) tol=1.e-6;
/* tolerance for shaping regularization */
for (i=0; i < dim; i++) {
sprintf(key,"rect%d",i+1);
if (!sf_getint(key,rect+i)) rect[i]=1;
/*( rect#=(1,1,...) smoothing radius on #-th axis )*/
}
/* triangle smoothing operator */
sf_trianglen_init(dim,rect,n);
sf_repeat_init(nt,1,sf_trianglen_lop);
sf_conjgrad_init(nt,nt,nt,nt,eps,tol,verb,false);
p = sf_floatalloc(nt);
} else {
/* initialize 2D gradient operator */
sf_igrad2_init(n[0],n[1]);
}
/* allocate memory for fastmarch */
t0 = sf_floatalloc(nt);
x0 = sf_floatalloc(nt);
f0 = sf_intalloc(nt);
/* allocate memory for update */
ds = sf_floatalloc(nt);
rhs = sf_floatalloc(nt);
/* output transformation matrix */
if (NULL != sf_getstring("t0")) {
t_0 = sf_output("t0");
sf_putint(t_0,"n3",niter+1);
}
if (NULL != sf_getstring("x0")) {
x_0 = sf_output("x0");
sf_putint(x_0,"n3",niter+1);
}
/* output auxiliary label */
if (NULL != sf_getstring("f0")) {
f_0 = sf_output("f0");
sf_settype(f_0,SF_INT);
sf_putint(f_0,"n3",niter+1);
}
/* output gradient */
if (NULL != sf_getstring("grad")) {
grad = sf_output("grad");
sf_putint(grad,"n3",niter);
}
/* output cost */
if (NULL != sf_getstring("cost")) {
cost = sf_output("cost");
sf_putint(cost,"n3",niter+1);
}
/* read mask (desired minimum) */
m0 = sf_intalloc(nt);
if (NULL != sf_getstring("mask")) {
mini = sf_input("mask");
sf_intread(m0,nt,mini);
sf_fileclose(mini);
} else {
for (it=0; it < nt; it++) m0[it] = -1;
}
/* read cost (desired minimum) */
rhs0 = sf_floatalloc(nt);
if (NULL != sf_getstring("mval")) {
mini = sf_input("mval");
sf_floatread(rhs0,nt,mini);
sf_fileclose(mini);
} else {
for (it=0; it < nt; it++) rhs0[it] = 0.;
}
/* read preconditioner */
if (NULL != sf_getstring("prec")) {
prec = sf_input("prec");
p0 = sf_floatalloc(nt);
sf_floatread(p0,nt,prec);
sf_fileclose(prec);
rhs1 = sf_floatalloc(nt);
}
/* fastmarch initialization */
fastmarch_init(n,o,d,order);
/* update initialization */
t2d_init(dim,n,d,nt0,dt0,ot0,nx0,dx0,ox0);
/* fastmarch */
fastmarch(t0,x0,f0,s);
/* caustic region (2D) */
t2d_caustic(x0,f0,n,d,thres);
/* set up operator */
t2d_set(t0,x0,f0,s,vd,vdt,vdx,m0,p0);
/* evaluate cost */
t2d_cost(rhs);
for (it=0; it < nt; it++) {
if (f0[it] >= 0 || m0[it] >= 0)
rhs[it] = 0.;
else
rhs[it] -= rhs0[it];
}
if (p0 == NULL) {
error0 = error1 = cblas_snrm2(nt,rhs,1);
} else {
for (it=0; it < nt; it++) rhs1[it] = p0[it]*rhs[it];
error0 = error1 = cblas_snrm2(nt,rhs1,1);
}
/* write optional outputs */
if (NULL!=t_0) sf_floatwrite(t0,nt,t_0);
if (NULL!=x_0) sf_floatwrite(x0,nt,x_0);
if (NULL!=f_0) sf_intwrite(f0,nt,f_0);
if (NULL!=cost) sf_floatwrite(rhs,nt,cost);
sf_warning("Start conversion, cost %g",1.);
/* nonlinear loop */
for (iter=0; iter < niter; iter++) {
/* solve ds */
if (shape) {
if (p0 == NULL)
sf_conjgrad(NULL,t2d_oper,sf_repeat_lop,p,ds,rhs,cgiter);
else
sf_conjgrad(t2d_prec,t2d_oper,sf_repeat_lop,p,ds,rhs,cgiter);
} else {
sf_solver_reg(t2d_oper,sf_cgstep,sf_igrad2_lop,2*nt,nt,nt,ds,rhs,cgiter,eps,"verb",verb,"end");
sf_cgstep_close();
}
/* add ds */
for (it=0; it < nt; it++) {
s[it] = s[it]+ds[it]+0.25*ds[it]*ds[it]/s[it];
}
/* fastmarch */
fastmarch(t0,x0,f0,s);
/* caustic region (2D) */
t2d_caustic(x0,f0,n,d,thres);
/* set up operator */
t2d_set(t0,x0,f0,s,vd,vdt,vdx,m0,p0);
/* evaluate cost */
t2d_cost(rhs);
for (it=0; it < nt; it++) {
if (f0[it] >= 0 || m0[it] >= 0)
rhs[it] = 0.;
else
rhs[it] -= rhs0[it];
}
if (p0 == NULL) {
error = cblas_snrm2(nt,rhs,1);
} else {
for (it=0; it < nt; it++) rhs1[it] = p0[it]*rhs[it];
error = cblas_snrm2(nt,rhs1,1);
}
error = cblas_snrm2(nt,rhs,1);
/* line search */
if (nline > 0 && error >= error1) {
scale = 0.5;
for (iline=0; iline < nline; iline++) {
for (it=0; it < nt; it++) {
s[it] = s[it]+(scale*ds[it])+0.25*(scale*ds[it])*(scale*ds[it])/s[it];
}
fastmarch(t0,x0,f0,s);
t2d_caustic(x0,f0,n,d,thres);
t2d_set(t0,x0,f0,s,vd,vdt,vdx,m0,p0);
t2d_cost(rhs);
for (it=0; it < nt; it++) {
if (f0[it] >= 0 || m0[it] >= 0)
rhs[it] = 0.;
else
rhs[it] -= rhs0[it];
}
if (p0 == NULL) {
error = cblas_snrm2(nt,rhs,1);
} else {
for (it=0; it < nt; it++) rhs1[it] = p0[it]*rhs[it];
error = cblas_snrm2(nt,rhs1,1);
}
error = cblas_snrm2(nt,rhs,1);
if (error < error1) {
sf_warning("Exist line search %d of %d",iline+1,nline);
} else {
scale *= 0.5;
}
}
}
error1 = error;
/* write optional outputs */
if (NULL!=t_0) sf_floatwrite(t0,nt,t_0);
if (NULL!=x_0) sf_floatwrite(x0,nt,x_0);
if (NULL!=f_0) sf_intwrite(f0,nt,f_0);
if (NULL!=cost) sf_floatwrite(rhs,nt,cost);
if (NULL!=grad) sf_floatwrite(ds,nt,grad);
sf_warning("Cost after iteration %d: %g",iter+1,error/error0);
}
/* write output */
if (velocity) {
for (it=0; it < nt; it++) {
s[it] = 1./sqrtf(s[it]);
}
}
sf_floatwrite(s,nt,out);
exit(0);
}
int main(int argc, char* argv[])
{
int i, ia, na, nx, ns, dim, niter;
int n[SF_MAX_DIM], m[SF_MAX_DIM], a[SF_MAX_DIM];
float a0, eps, *mm, *pp;
bool verb, *known;
sf_filter aa;
char* lagfile;
sf_file in, out, filt, lag, mask;
sf_init (argc,argv);
in = sf_input("in");
filt = sf_input("filt");
out = sf_output("out");
dim = sf_filedims (in,n);
if (!sf_histint(filt,"n1",&na)) sf_error("No n1= in filt");
aa = sf_allocatehelix (na);
if (!sf_histfloat(filt,"a0",&a0)) a0=1.;
if (!sf_histints(filt,"a",a,dim)) {
for (i=0; i < dim; i++) {
a[i]=1;
}
}
if (NULL != (lagfile = sf_getstring("lag")) /* file with filter lags */
||
NULL != (lagfile = sf_histstring(filt,"lag"))) {
lag = sf_input(lagfile);
sf_intread(aa->lag,na,lag);
} else {
lag = NULL;
for( ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
}
if (!sf_getints ("n",m,dim) && (NULL == lag ||
!sf_histints (lag,"n",m,dim))) {
for (i=0; i < dim; i++) {
m[i] = n[i];
}
}
if (NULL != lag) sf_fileclose(lag);
bound (dim, m, n, a, aa);
sf_floatread (aa->flt,na,filt);
sf_fileclose(filt);
for( ia=0; ia < na; ia++) {
aa->flt[ia] /= a0;
}
if (!sf_getint ("ns",&ns)) sf_error("Need ns=");
/* scaling */
if (!sf_getint("niter",&niter)) niter=100;
/* Number of iterations */
if (!sf_getfloat("eps",&eps)) eps=1.;
/* regularization parameter */
if (!sf_getbool("verb",&verb)) verb=true;
/* verbosity flag */
nx = 1;
for( i=0; i < dim; i++) {
nx *= n[i];
}
mm = sf_floatalloc (nx);
pp = sf_floatalloc (nx);
known = sf_boolalloc (nx);
sf_mask_init(known);
hshape_init (nx,ns,aa);
sf_conjgrad_init(nx, nx, nx, nx, eps, 1.e-8, verb, false);
if (NULL != sf_getstring("mask")) {
/* optional input mask file for known data */
mask = sf_input("mask");
sf_floatread(mm,nx,mask);
sf_fileclose(mask);
for (i=0; i < nx; i++) {
known[i] = (bool) (mm[i] != 0.);
}
sf_floatread(mm,nx,in);
} else {
sf_floatread(mm,nx,in);
for (i=0; i < nx; i++) {
known[i] = (bool) (mm[i] != 0.);
}
}
sf_conjgrad(NULL, sf_mask_lop, hshape_lop, pp, mm, mm, niter);
sf_floatwrite (mm,nx,out);
exit (0);
}
int main(int argc, char* argv[])
{
bool velocity, causal, limit, verb, shape;
int dimw, dimt, i, n[SF_MAX_DIM], rect[SF_MAX_DIM], iw, nw, ir, nr;
long nt, *order;
int iter, niter, cgiter, count;
int *ff, *dp, *mp, nloop;
float o[SF_MAX_DIM], d[SF_MAX_DIM], *dt, *dw, *dv, *t, *w, *t0, *w1, *p=NULL;
float eps, tol, thres, rhsnorm, rhsnorm0, rhsnorm1, rate, gama;
char key[6];
sf_file in, out, reco, grad, mask, prec;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
/* read dimension */
dimw = sf_filedims(in,n);
nw = 1;
for (i=0; i < dimw; i++) {
sprintf(key,"d%d",i+1);
if (!sf_histfloat(in,key,d+i)) sf_error("No %s= in input.",key);
sprintf(key,"o%d",i+1);
if (!sf_histfloat(in,key,o+i)) o[i]=0.;
nw *= n[i];
}
if (dimw > 2) sf_error("Only works for 2D now.");
n[2] = n[1]; d[2] = d[1]; o[2] = o[1];
dimt = 3; nr = n[1]*n[2]; nt = nw*n[2];
/* read initial velocity */
w = sf_floatalloc(nw);
sf_floatread(w,nw,in);
if (!sf_getbool("velocity",&velocity)) velocity=true;
/* if y, the input is velocity; n, slowness-squared */
/* convert to slowness-squared */
if (velocity) {
for (iw=0; iw < nw; iw++)
w[iw] = 1./w[iw]*1./w[iw];
dv = sf_floatalloc(nw);
} else {
dv = NULL;
}
if (!sf_getbool("limit",&limit)) limit=false;
/* if y, limit computation within receiver coverage */
if (!sf_getbool("shape",&shape)) shape=false;
/* shaping regularization (default no) */
/* read record */
if (NULL == sf_getstring("reco"))
sf_error("Need record reco=");
reco = sf_input("reco");
t0 = sf_floatalloc(nr);
sf_floatread(t0,nr,reco);
sf_fileclose(reco);
/* read receiver mask */
if (NULL == sf_getstring("mask")) {
mask = NULL;
dp = NULL;
} else {
mask = sf_input("mask");
dp = sf_intalloc(nr);
sf_intread(dp,nr,mask);
sf_fileclose(mask);
}
/* read model mask */
if (NULL == sf_getstring("prec")) {
prec = NULL;
mp = NULL;
} else {
prec = sf_input("prec");
mp = sf_intalloc(nw);
sf_intread(mp,nw,prec);
sf_fileclose(prec);
}
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
if (!sf_getint("niter",&niter)) niter=5;
/* number of inversion iterations */
if (!sf_getint("cgiter",&cgiter)) cgiter=10;
/* number of conjugate-gradient iterations */
if (!sf_getfloat("thres",&thres)) thres=5.e-5;
/* threshold (percentage) */
if (!sf_getfloat("tol",&tol)) tol=1.e-3;
/* tolerance for bisection root-search */
if (!sf_getint("nloop",&nloop)) nloop=10;
/* number of bisection root-search */
/* output gradient at each iteration */
if (NULL != sf_getstring("grad")) {
grad = sf_output("grad");
sf_putint(grad,"n3",niter);
} else {
grad = NULL;
}
if (!sf_getfloat("eps",&eps)) eps=0.;
/* regularization parameter */
if (shape) {
for (i=0; i < dimw; i++) {
sprintf(key,"rect%d",i+1);
if (!sf_getint(key,rect+i)) rect[i]=1;
/*( rect#=(1,1,...) smoothing radius on #-th axis )*/
}
/* triangle smoothing operator */
sf_trianglen_init(dimw,rect,n);
sf_repeat_init(nw,1,sf_trianglen_lop);
sf_conjgrad_init(nw,nw,nr,nr,eps,1.e-6,verb,false);
p = sf_floatalloc(nw);
} else {
/* initialize 2D gradient operator */
sf_igrad2_init(n[0],n[1]);
}
/* allocate temporary array */
t = sf_floatalloc(nt);
dw = sf_floatalloc(nw);
dt = sf_floatalloc(nr);
w1 = sf_floatalloc(nw);
ff = sf_intalloc(nt);
if (!sf_getbool("causal",&causal)) causal=true;
/* if y, neglect non-causal branches of DSR */
/* initialize eikonal */
dsreiko_init(n,o,d,
thres,tol,nloop,
causal,limit,dp);
/* initialize operator */
dsrtomo_init(dimt,n,d);
/* upwind order */
order = dsrtomo_order();
/* initial misfit */
dsreiko_fastmarch(t,w,ff,order);
dsreiko_mirror(t);
/* calculate L2 data-misfit */
for (ir=0; ir < nr; ir++) {
if (dp == NULL || dp[ir] == 1) {
dt[ir] = t0[ir]-t[(long) ir*n[0]];
} else {
dt[ir] = 0.;
}
}
rhsnorm0 = cblas_snrm2(nr,dt,1);
rhsnorm = rhsnorm0;
rhsnorm1 = rhsnorm;
rate = rhsnorm1/rhsnorm0;
sf_warning("L2 misfit after iteration 0 of %d: %g",niter,rate);
/* iterations over inversion */
for (iter=0; iter < niter; iter++) {
/* clean-up */
for (iw=0; iw < nw; iw++) dw[iw] = 0.;
/* set operator */
dsrtomo_set(t,w,ff,dp,mp);
/* solve dw */
if (shape) {
sf_conjgrad(NULL,dsrtomo_oper,sf_repeat_lop,p,dw,dt,cgiter);
} else {
sf_solver_reg(dsrtomo_oper,sf_cgstep,sf_igrad2_lop,2*nw,nw,nr,dw,dt,cgiter,eps,"verb",verb,"end");
sf_cgstep_close();
}
/* output gradient */
if (grad != NULL) {
if (velocity) {
for (iw=0; iw < nw; iw++) {
dv[iw] = -dw[iw]/(2.*sqrtf(w[iw])*(w[iw]+dw[iw]/2.));
}
sf_floatwrite(dv,nw,grad);
} else {
sf_floatwrite(dw,nw,grad);
}
}
/* line search */
gama = 0.5;
for (count=0; count < 5; count++) {
/* update slowness */
for (iw=0; iw < nw; iw++)
w1[iw] = (w[iw]+gama*dw[iw])*(w[iw]+gama*dw[iw])/w[iw];
/* compute new misfit */
dsreiko_fastmarch(t,w1,ff,order);
dsreiko_mirror(t);
for (ir=0; ir < nr; ir++) {
if (dp == NULL || dp[ir] == 1) {
dt[ir] = t0[ir]-t[(long) ir*n[0]];
} else {
dt[ir] = 0.;
}
}
rhsnorm = cblas_snrm2(nr,dt,1);
rate = rhsnorm/rhsnorm1;
if (rate < 1.) {
for (iw=0; iw < nw; iw++) w[iw] = w1[iw];
rhsnorm1 = rhsnorm;
rate = rhsnorm1/rhsnorm0;
break;
}
gama *= 0.5;
}
if (count == 5) {
sf_warning("Line-search failure at iteration %d of %d.",iter+1,niter);
break;
}
sf_warning("L2 misfit after iteration %d of %d: %g (line-search %d)",iter+1,niter,rate,count);
}
/* convert to velocity */
if (velocity) {
for (iw=0; iw < nw; iw++) {
w[iw] = 1./sqrtf(w[iw]);
}
}
sf_floatwrite(w,nw,out);
exit(0);
}
int main(int argc, char* argv[])
{
int n12, i, i1, i2, rect, order, niter;
float **img, **grad, **grad1, **grad2, *y, **x;
float med, t, t2, tol[2], band;
sf_eno2 g[2];
sf_file in, out;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n12 = n1*n2;
if (!sf_getint("rect",&rect)) rect=3;
/* smoothing radius */
t = (rect*rect-1)/6.0;
sf_runge_init(2,1,t/2);
if (!sf_getint("order",&order)) order=3;
/* interpolation order */
if (!sf_getfloat("tol",&tol[0])) tol[0]=0.1;
/* error tolerance */
tol[1]=tol[0];
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getfloat("band",&band)) band=1.;
/* narrow band */
img = sf_floatalloc2(n1,n2);
grad = sf_floatalloc2(n1,n2);
grad1 = sf_floatalloc2(n1,n2);
grad2 = sf_floatalloc2(n1,n2);
y = sf_floatalloc(n12);
x = sf_floatalloc2(2,n12);
g[0] = sf_eno2_init (order, n1, n2);
g[1] = sf_eno2_init (order, n1, n2);
sf_floatread(img[0],n12,in);
/* compute gradient squared */
sf_sobel2 (n1,n2,img,grad);
/* normalize by median */
for (i=0; i < n12; i++) {
y[i] = grad[0][i];
}
med = sf_quantile(n12/2,n12,y);
for (i=0; i < n12; i++) {
grad[0][i] = -0.5*logf(1.+grad[0][i]/med);
}
/* compute gradient */
sf_sobel (n1,n2,grad,grad1,grad2);
sf_eno2_set (g[0], grad1);
sf_eno2_set (g[1], grad2);
/* convection */
i=0;
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
if (fabsf(img[i2][i1]) < band) {
x[i][0] = i1;
x[i][1] = i2;
t2 = sf_ode23 (t,tol, x[i], g, rhs, term);
if (t2 >= t) {
y[i] = img[i2][i1];
i++;
}
}
}
}
/* diffusion */
sf_int2_init (x, 0,0,1,1,n1,n2, sf_lin_int, 2, i);
sf_triangle2_init(rect,rect, n1, n2, 1);
sf_conjgrad_init(n12, n12, i, i, 1.0/i, 1.e-8, true, false);
sf_conjgrad(NULL,
sf_int2_lop, sf_triangle2_lop, grad[0], img[0], y, niter);
sf_floatwrite(img[0],n12,out);
exit(0);
}
int main(int argc, char* argv[])
{
int i, niter, n1, n2, n12, i3, n3, ns, order, np;
float *mm, *dd, *xx, **pp, **qq, lam, eps;
bool *known;
sf_file in, out, dip, mask;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
dip = sf_input("dip");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n12 = n1*n2;
n3 = sf_leftsize(in,2);
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
pp = sf_floatalloc2(n1,n2);
mm = sf_floatalloc(n12);
xx = sf_floatalloc(n12);
known = sf_boolalloc(n12);
np = sf_leftsize(dip,2);
if (np > n3) {
qq = sf_floatalloc2(n1,n2);
} else {
qq = NULL;
}
if (NULL != sf_getstring ("mask")) {
mask = sf_input("mask");
dd = sf_floatalloc(n12);
} else {
mask = NULL;
dd = NULL;
}
if (!sf_getint("ns",&ns)) ns=1;
/* smoothing radius */
if (!sf_getfloat("eps",&eps)) eps=0.01;
/* regularization */
sf_mask_init(known);
for (i3=0; i3 < n3; i3++) {
sf_warning("slice %d of %d",i3+1,n3);
sf_floatread(mm,n12,in);
for (i=0; i < n12; i++) {
xx[i] = mm[i];
}
if (NULL != mask) {
sf_floatread(dd,n12,mask);
} else {
dd = mm;
}
/* figure out scaling and make known data mask */
lam = 0.;
for (i=0; i < n12; i++) {
if (dd[i] != 0.) {
known[i] = true;
lam += 1.;
} else {
known[i] = false;
}
}
lam = sqrtf(lam/n12);
/* read dip */
sf_floatread(pp[0],n12,dip);
sf_conjgrad_init(n12, n12, n12, n12, lam, 10*FLT_EPSILON, true, true);
if (NULL != qq) {
sf_floatread(qq[0],n12,dip);
pwsmooth2_init(ns, n1, n2, order, eps, pp, qq);
sf_conjgrad(NULL,sf_mask_lop,pwsmooth2_lop,xx,mm,mm,niter);
pwsmooth2_close();
} else {
pwsmooth_init(ns, n1, n2, order, eps, pp);
sf_conjgrad(NULL,sf_mask_lop,pwsmooth_lop,xx,mm,mm,niter);
pwsmooth_close();
}
sf_conjgrad_close();
sf_floatwrite (mm,n12,out);
}
exit(0);
}
