void smoothpwd(int niter /* number of iterations */, int ncycle /* number of cycles */, float* weight /* data weighting */, float* data /* input data */, float* der /* output derivative */, bool verb /* verbosity flag */, float eps /* regularization parameter */) /*< find the derivative >*/ { int i, iter; for (i=0; i < n; i++) { w[i] = 1.; } for (iter=0; iter < ncycle; iter++) { if (NULL != weight) { sf_solver_prec (sf_repeat_lop,sf_cgstep,predict_smooth_lop, n,n,n,der,data,niter,eps, "wt",weight,"verb",verb,"mwt",w,"xp",p,"end"); } else { sf_solver_prec (sf_repeat_lop,sf_cgstep,predict_smooth_lop, n,n,n,der,data,niter,eps, "verb",verb,"mwt",w,"xp",p,"end"); } sf_cgstep_close(); for (i=0; i < n; i++) { w[i] = p[i]; /* "Cauchy" weight + positivity */ } } }
void mis2(int niter /* number of iterations */, int nx /* model size */, float *xx /* model */, sf_filter aa /* helix filter */, const bool *known /* mask for known data */, float eps /* regularization parameter */, bool doprec /* to apply preconditioning */) /*< interpolate >*/ { int ix; float *dd; if (doprec) { /* preconditioned */ sf_mask_init(known); sf_polydiv_init(nx, aa); sf_solver_prec(sf_mask_lop, sf_cgstep, sf_polydiv_lop, nx, nx, nx, xx, xx, niter, eps, "end"); sf_polydiv_close(); } else { /* regularized */ dd = sf_floatalloc(nx); for (ix=0; ix < nx; ix++) { dd[ix]=0.; } sf_helicon_init(aa); sf_solver (sf_helicon_lop, sf_cgstep, nx, nx, xx, dd, niter, "known", known, "x0", xx, "end"); free(dd); } sf_cgstep_close(); }
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 signoi_lop (bool adj, bool add, int n1, int n2, float *data, float *sign) /*< linear operator >*/ { sf_helicon_init (nn); sf_polydiv_init (nd, ss); sf_adjnull(adj,add,n1,n2,data,sign); sf_helicon_lop (false, false, n1, n1, data, dd); sf_solver_prec(sf_helicon_lop, sf_cgstep, sf_polydiv_lop, nd, nd, nd, sign, dd, niter, eps, "verb", verb, "end"); sf_cgstep_close(); nn++; ss++; }
int main(int argc, char* argv[]) { int i, n1, n2, n12, n3, nk, n12k, niter, nliter, iter, i3, order; float eps, *d, *s, ***pp, *w=NULL, *p=NULL; bool verb; sf_file in, out, dips, weight=NULL; sf_init (argc,argv); in = sf_input("in"); dips = sf_input("dips"); 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"); n3 = sf_leftsize(in,2); if (!sf_histint(dips,"n1",&i) || i != n1) sf_error("Wrong n1= in dips"); if (!sf_histint(dips,"n2",&i) || i != n2) sf_error("Wrong n2= in dips"); if (sf_histint(dips,"n4",&i) && i != n3) sf_error("Wrong n4= in dips"); if (!sf_histint(dips,"n3",&nk)) nk=1; sf_putint (out,"n3",nk); sf_putint (out,"n4",n3); n12 = n1*n2; n12k = n12*nk; if (!sf_getint ("niter",&niter)) niter=50; /* maximum number of iterations */ if (!sf_getint ("nliter",&nliter)) nliter=1; /* number of reweighting iterations */ if (!sf_getfloat ("eps",&eps)) eps=0.; /* regularization parameter */ if (!sf_getbool("verb",&verb)) verb = false; /* verbosity flag */ if (!sf_getint("order",&order)) order=1; /* accuracy order */ s = sf_floatalloc(n12k); d = sf_floatalloc(n12); pp = sf_floatalloc3(n1,n2,nk); if (nliter > 1) { w = sf_floatalloc(n12k); p = sf_floatalloc(n12k); if (NULL != sf_getstring("weight")) { weight = sf_output("weight"); sf_putint(weight,"n3",nk); sf_putint(weight,"n4",n3); } } predk_init(nk,n1,n2,0.0001,order,pp); copyk_init(nk,n12); for (i3=0; i3 < n3; i3++) { if (verb) sf_warning("slice %d of %d",i3+1,n3); sf_floatread (d,n12,in); sf_floatread (pp[0][0],n12k,dips); if (1 == nliter) { sf_solver_prec (copyk_lop,sf_cgstep,predk_lop, n12k,n12k,n12,s,d,niter,eps,"verb",verb,"end"); sf_cgstep_close(); } else { for (i=0; i < n12k; i++) { w[i] = 1.; } for (iter=0; iter < nliter; iter++) { sf_solver_prec (copyk_lop,sf_cgstep,predk_lop, n12k,n12k,n12,s,d,niter,eps, "verb",verb,"mwt",w,"xp",p,"end"); sf_cgstep_close(); if (iter < nliter-1) { for (i=0; i < n12k; i++) { w[i] = fabsf(p[i]); /* "Cauchy" weight */ } } else { for (i=0; i < n12k; i++) { w[i] *= p[i]; } } } if (NULL != weight) sf_floatwrite(w,n12k,weight); } sf_floatwrite(s,n12k,out); } exit(0); }
int main(int argc, char* argv[]) { int i1, i2, n1, n2, n12, niter, iter, nliter; float *data, *modl, *wght, eps, **nr; bool verb; sf_file in, out, rect; sf_init(argc,argv); in = sf_input("in"); out = sf_output("out"); rect = sf_input("rect"); if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input"); if (SF_FLOAT != sf_gettype(rect)) sf_error("Need float rect"); if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input"); n2 = sf_leftsize(in,1); n12 = n1*n2; data = sf_floatalloc(n12); modl = sf_floatalloc(n12); wght = sf_floatalloc(n12); nr = sf_floatalloc2(n1,n2); sf_floatread(data,n12,in); sf_floatread(nr[0],n12,rect); for (i1=0; i1 < n12; i1++) { wght[i1] = 1.; } if (!sf_getint("niter",&niter)) niter=100; /* number of iterations */ if (!sf_getint("nliter",&nliter)) nliter=1; /* number of nonlinear iterations */ if (!sf_getbool("verb",&verb)) verb=false; /* verbosity flag */ if (!sf_getfloat("eps",&eps)) eps=0.; /* regularization parameter */ nsmooth1_init(n1,n2,nr); sf_weight_init(wght); sf_hilbert_init(n1, 10, 1.); for (iter=0; iter < nliter; iter++) { sf_solver_prec(nsmooth1_lop,sf_cgstep,sf_weight_lop, n12,n12,n12,modl,data,niter,eps, "verb",verb,"end"); sf_cgstep_close(); for (i2=0; i2 < n2; i2++) { sf_hilbert(modl+i2*n1,wght+i2*n1); for (i1=0; i1 < n1; i1++) { wght[i1+i2*n1] = hypotf(modl[i1+i2*n1],wght[i1+i2*n1]); } } } sf_floatwrite(modl,n12,out); exit(0); }
int main(int argc, char* argv[]) { int nt, ncmp, ncdp, nh, nh2, nm, nd, memsize, niter, reg, ix, ih, i3, i2, i1, iter, filt, nw, np; float t0, cmp0, cdp0, h0, dt, dcmp, dcdp, dh, apt, rho, aal, norm; bool verb, half, amp; float ***data, ***modl, **vrms, **mask, *off, *error=NULL; float **pp, **qq, *aa; char *errfile; sf_file in, out, vel, offset, err=NULL; sf_file fdip; int ompchunk = 1; int ompnth = 1; #ifdef _OPENMP int ompath=1; #endif /*------------------------------------------------------------*/ sf_init(argc,argv); if(! sf_getint("ompchunk",&ompchunk)) ompchunk=1; /* OpenMP data chunk size */ #ifdef _OPENMP if(! sf_getint("ompnth", &ompnth)) ompnth=0; /* OpenMP available threads */ #pragma omp parallel ompath=omp_get_num_threads(); if(ompnth<1) ompnth=ompath; omp_set_num_threads(ompnth); sf_warning("using %d threads of a total of %d",ompnth,ompath); #endif in = sf_input("in"); vel = sf_input("vel"); out = sf_output("out"); if (!sf_getbool("verb",&verb)) verb=false; /* verbosity flag */ if (!sf_getbool("half",&half)) half = true; /* if y, the third axis is half-offset instead of full offset */ if (!sf_getbool("amp",&)) amp = true; /* if y, use amplitue factor */ if (!sf_histint(in,"n1",&nt)) sf_error("No n1= in input"); if (!sf_histfloat(in,"d1",&dt)) sf_error("No d1= in input"); if (!sf_histfloat(in,"o1",&t0)) sf_error("No o1= in input"); if (!sf_histint(in,"n2",&ncmp)) sf_error("No n2= in input"); if (!sf_histfloat(in,"d2",&dcmp)) sf_error("No d2= in input"); if (!sf_histfloat(in,"o2",&cmp0)) sf_error("No o2= in input"); if (!sf_getint("ncdp",&ncdp)) ncdp = ncmp; if (!sf_getfloat("dcdp",&dcdp)) dcdp = dcmp; if (!sf_getfloat("cdp0",&cdp0)) cdp0 = cmp0; sf_putint(out,"n2",ncdp); sf_putfloat(out,"d2",dcdp); sf_putfloat(out,"o2",cdp0); if (!sf_histint(in,"n3",&nh)) sf_error("No n3= in input"); if (NULL != sf_getstring("offset")) { offset = sf_input("offset"); nh2 = sf_filesize(offset); if (nh2 != nh*ncmp) sf_error("Wrong dimensions in offset, it should be %d",nh*ncmp); off = sf_floatalloc(nh2); sf_floatread (off,nh2,offset); sf_fileclose(offset); if (!half) { for (ih = 0; ih < nh2; ih++) { off[ih] *= 0.5; } } } else { if (!sf_histfloat(in,"o3",&h0)) sf_error("No o3="); if (!sf_histfloat(in,"d3",&dh)) sf_error("No d3="); if (!half) dh *= 0.5,h0 *= 0.5; off = sf_floatalloc(nh*ncmp); for (ix = 0; ix < ncmp; ix++) { for (ih = 0; ih < nh; ih++) { off[ih*ncmp+ix] = h0 + ih*dh; } } offset = NULL; } if (!sf_getint("reg",®)) reg=0; /* regularization type */ if (!sf_getfloat("antialias",&aal)) aal = 1.0; /* antialiasing */ if (!sf_getfloat("apt",&apt)) apt=ncmp; /* migration aperture */ if (!sf_getfloat("rho",&rho)) rho = 1.-1./nt; /* Leaky integration constant */ if (!sf_getint("niter",&niter)) niter=5; /* number of iterations */ nm = nt*ncdp*nh; nd = nt*ncmp*nh; vrms = sf_floatalloc2(nt,ncdp); mask = sf_floatalloc2(ncmp,nh); data = sf_floatalloc3(nt,ncmp,nh); modl = sf_floatalloc3(nt,ncdp,nh); /* read velocity file */ sf_floatread(vrms[0],nt*ncdp,vel); sf_fileclose(vel); memsize = nm+nd+nt*ncdp+ncmp*nh; if (verb) sf_warning("memory needs: %f G (%f M)",4.*memsize/1024/1024/1024,4.*memsize/1024/1024); if (niter > 0) { errfile = sf_getstring("err"); /* output file for error */ if (NULL != errfile) { err = sf_output(errfile); sf_putint(err,"n1",niter); sf_putfloat(err,"d1",1); sf_putfloat(err,"o1",1); sf_putstring(err,"label1","Iteration Number"); sf_putstring(err,"label2","Relative Squared Error"); sf_putint(err,"n2",1); sf_putint(err,"n3",1); } error = sf_floatalloc(niter); } sf_floatread(data[0][0],nd,in); for (i3=0; i3 < nh; i3++) { for (i2=0; i2 < ncmp; i2++) { mask[i3][i2]=cblas_sdot(nt,data[i3][i2],1,data[i3][i2],1); } } tkirmig_init(ompnth,ompchunk,nt,dt,t0,ncmp,dcmp,cmp0,ncdp,dcdp,cdp0,nh,dh,h0,apt,aal,rho,vrms,off,mask,amp,verb); sf_cdstep_init(); if (verb) sf_warning("Iteration begin..."); if (reg == 0) sf_solver(tkirmig_lop,sf_cdstep,nm,nd,modl[0][0],data[0][0], niter,"nmem",0,"nfreq",niter,"err",error,"end"); else if (reg == 1) { filt=2; aa=sf_floatalloc(filt); aa[0]=1.; aa[1]=-1.; tcaih_init(filt,aa,nt,ncdp,nh); sf_solver_reg(tkirmig_lop,sf_cdstep,tcaih_lop,nm+filt*nt*ncdp,nm,nd, modl[0][0],data[0][0],niter,0.01,"nmem",0,"nfreq",niter, "err",error,"end"); } else if (reg == 2) { sf_causinth_init(nt,ncdp,nh); sf_solver_prec(tkirmig_lop,sf_cdstep,sf_causinth_lop,nm,nm,nd, modl[0][0],data[0][0],niter,0.01,"nmem",0,"nfreq",niter, "err",error,"end"); } else if (reg == 3) { sf_triangleh_init(3,nt,ncdp,nh); sf_solver_prec(tkirmig_lop,sf_cdstep,sf_triangleh_lop,nm,nm,nd, modl[0][0],data[0][0],niter,0.01,"nmem",0,"nfreq",niter, "err",error,"end"); } else if (reg == 4) { sf_warning("pwd constraints along t-x plane and smoothing along offset axis"); if (!sf_getstring("fdip")) sf_error("Need input dip file!"); if (!sf_getint("nw",&nw)) nw=3; fdip = sf_input("fdip"); if (!sf_histint(fdip,"n3",&np)) np=1; sf_warning("np=%d",np); pp = sf_floatalloc2(nt,ncdp); if (np > 1) { qq = sf_floatalloc2(nt,ncdp); } else { qq = NULL; } if (NULL != qq) { predicth2_init(nt,ncdp,nh,0.1,nw,pp,qq); } else { predicth_init(nt,ncdp,nh,0.1,nw,1,false); predict_set(pp); } sf_floatread(pp[0],nt*ncdp,fdip); if (NULL != qq) { sf_floatread(qq[0],nt*ncdp,fdip); sf_solver_prec(tkirmig_lop,sf_cdstep,predicth2_lop,nm,nm,nd, modl[0][0],data[0][0],niter,0.01,"nmem",0,"nfreq",niter, "err",error,"end"); predict2_close(); } else { sf_solver_prec(tkirmig_lop,sf_cdstep,predicth_lop,nm,nm,nd, modl[0][0],data[0][0],niter,0.01,"nmem",0,"nfreq",niter, "err",error,"end"); predict_close(); } } sf_cdstep_close(); sf_floatwrite(modl[0][0],nm,out); if (NULL != err) { for (i3=0; i3 < nh; i3++) { for (i2=0; i2 < ncmp; i2++) { for (i1=0; i1 < nt; i1++) { norm += data[i3][i2][i1]*data[i3][i2][i1]; } } } for (iter=0; iter < niter; iter++) error[iter] /=norm; sf_floatwrite(error,niter,err); } sf_warning("iter/niter=%d/%d, err=%f",iter,niter,error); exit(0); }
void adaptsub_icaf(float *input1, float *input2, float *output, int ns, int ntr, int order, int Twin, int Xwin, float mu, char *method, bool verb) /*<adaptive matched-filter subtraction using internal convolution>*/ { float value; float **Data,**Mult; float *d,*m,*x; int i,j,ii,jj,ind,ind2,twin,xwin,k,samples; int oo=(Twin+1)/2 ; twin=(Twin-1)/2; xwin=(Xwin-1)/2; k=Twin*Xwin; samples=ns*ntr; Data=sf_floatalloc2(ntr+Xwin-1,ns+Twin-1); Mult=sf_floatalloc2(ntr+Xwin-1,ns+Twin-1); d = sf_floatalloc(k); m = sf_floatalloc(k); x = sf_floatalloc(order); for (i=0;i<order;i++) x[i]=0.0; pad (input1, Data, ns, ntr, twin, xwin); pad (input2, Mult, ns, ntr, twin, xwin); for(ind=0,j=0; j < ntr; j++) { for(i=0; i < ns; i++,ind++) { value=0.0; for(ind2=0,jj=0; jj < Xwin; jj++) { // patching 2D for(ii=0; ii < Twin; ii++,ind2++) { d[ind2] = Data[i+ii][j+jj]; m[ind2] = Mult[i+ii][j+jj]; } } sf_cdstep_init(); if ('o' == method[0] || 'O' == method[0]) { icaf1_init (k /* data length */, m /* data [k] */, 1 /* filter lag (lag=1 is causal) */); sf_solver_prec (icaf1_lop, sf_cdstep, sf_copy_lop, order, order, k, x, d, 3*order, mu,"end"); } else { filter1d_icaf_init(Twin /* window time length */, Xwin /* window space length */, m /* signal to be matched */); sf_solver_reg (filter1d_icaf_lop, sf_cdstep, sf_copy_lop, order, order, k, x, d, 3*order, mu,"end"); filter1d_icaf_close(); } sf_cdstep_close(); for(ii=0 ; ii < order ; ii++) { value += x[ii] * Mult[i + oo -ii-1][j+xwin]; // matched signal } output[ind] = input1[ind] - value; // subtraction } if (verb) sf_warning("\r\t\t\t\t\t\t\t\t\t %3.2f%% ",(float)100*(ind+1)/samples); } free(Data[0]); free(Data); free(Mult[0]); free(Mult); free(d); free(m); free(x); }
void adaptsub_tcaf(float *input1, float *input2, float *output, int ns, int ntr, int order, int Twin, int Xwin, float mu, char *method, bool verb) /*<adaptive matched-filter subtraction using transient convolution>*/ { float value; float **Data,**Mult; float *d,*m,*x; int nd,nm; int i,j,ii,jj,ind,twin,xwin,samples; int o = (order-1)/2; int oo = (Twin+1)/2+(order-1)/2 ; twin=(Twin-1)/2; xwin=(Xwin-1)/2; samples=ns*ntr; Data=sf_floatalloc2(ntr+Xwin-1,ns+Twin-1); Mult=sf_floatalloc2(ntr+Xwin-1,ns+Twin-1); ; nm = Twin*Xwin; if ('o' == method[0] || 'O' == method[0]) nd = (Twin*Xwin) + order-1; else nd = (Twin+order-1)*Xwin; d = sf_floatalloc(nd); m = sf_floatalloc(nm); x = sf_floatalloc(order); for (i=0;i<order;i++) x[i]=0.0; pad (input1, Data, ns, ntr, twin, xwin); pad (input2, Mult, ns, ntr, twin, xwin); for(ind=0,j=0; j < ntr; j++) { for(i=0; i < ns; i++,ind++) { value=0.0; for(jj=0; jj < Xwin; jj++) { // patching 2D for(ii=0; ii < Twin; ii++) { if ('o' == method[0] || 'O' == method[0]) d[ii+(jj * Twin) + o] = Data[i+ii][j+jj]; else d[ii+(jj* (Twin+2*o) ) + o] = Data[i+ii][j+jj]; m[ii+(jj*Twin)] = Mult[i+ii][j+jj]; } } //sf_cdstep_init(); if ('o' == method[0] || 'O' == method[0]) { tcaf1_init (nm /* data length */, m /* data [k] */); sf_solver_prec (tcaf1_lop, sf_cdstep, sf_copy_lop, order, order, nd, x, d, 3*order, mu,"end"); } else { filter1d_tcaf_init(Twin /* window time length */, Xwin /* window space length */, order /* filter order */, m /* signal to be matched */); sf_solver_reg (filter1d_tcaf_lop, sf_cdstep, sf_copy_lop, order, order, nd, x, d, 3*order, mu,"end"); filter1d_tcaf_close(); } sf_cdstep_close(); for(ii=0 ; ii < order ; ii++) { value += x[ii] * Mult[i + oo -(ii+1)][j+xwin]; // matched signal } output[ind] = input1[ind] - value; // subtraction } if (verb) sf_warning("\r\t\t\t\t\t\t\t\t\t %3.2f%% ",(float)100*(ind+1)/samples); } free(Data[0]); free(Data); free(Mult[0]); free(Mult); free(d); free(m); free(x); }
int main (int argc, char* argv[]) { sf_file in, out, fileDweight, fileRefl, fileDiff; // data int tn; float to, td; int dipn; float dipo, dipd; int sdipn; float sdipo, sdipd; // reflection model int dip0n; float dip0o, dip0d; // dips in x-direction int sdip0n; float sdip0o, sdip0d; // dips in y-direction // diffraction model int xin; float xio, xid; // xi in x-direction int sxin; float sxio, sxid; // xi in y-direction int xn, yn, dagNum; float *data = NULL, *model = NULL, *dweight = NULL; int im, ix; int invMod; int niter, liter, iter; bool adj, verb, isAA; float eps; float *w, *p; int dataSize, diffSize, reflSize, modelSize, id; sf_init (argc, argv); in = sf_input ("in"); out = sf_output ("out"); fileDweight = NULL; if ( NULL != sf_getstring ("dweight") ) { /* input file containing data weights */ fileDweight = sf_input ("dweight"); } if (!sf_histint (in, "n1", &tn) ) sf_error ("No n1= in input"); if (!sf_histfloat (in, "o1", &to) ) sf_error ("No o1= in input"); if (!sf_histfloat (in, "d1", &td) ) sf_error ("No d1= in input"); if (!sf_histint (in, "n4", &xn) ) sf_error ("No n4= in input"); if (!sf_histint (in, "n5", &yn) ) sf_error ("No n5= in input"); dagNum = xn * yn; if (!sf_getbool ("verb", &verb)) verb=false; /* verbosity flag */ if (!sf_getbool ( "adj", &adj )) adj=false; /* adjoint flag */ if (!sf_getbool ("isAA", &isAA)) isAA = false; /* if y, apply anti-aliasing */ if (!sf_getint ("liter",&liter)) liter=100; /* number of linear iterations (for inversion) */ if (!sf_getint ("niter",&niter)) niter=0; /* number of nonlinear iterations (for inversion) */ if (!sf_getfloat ("eps",&eps)) eps=0.; /* regularization parameter */ if (!sf_getbool("verb",&verb)) verb = false; /* verbosity flag */ if (!sf_getint ("invMod", &invMod)) invMod=2; /* number of nonlinear iterations (for inversion) */ if (adj) { // data -> model fileDiff = out; fileRefl = sf_output ("reflMod"); if (!sf_histfloat (in, "o2", &dipo) ) sf_error ("No o2= in input"); if (!sf_histfloat (in, "d2", &dipd) ) sf_error ("No d2= in input"); if (!sf_histint (in, "n2", &dipn) ) sf_error ("No n2= in input"); if (!sf_histfloat (in, "o3", &sdipo) ) sf_error ("No o3= in input"); if (!sf_histfloat (in, "d3", &sdipd) ) sf_error ("No d3= in input"); if (!sf_histint (in, "n3", &sdipn) ) sf_error ("No n3= in input"); // reflection model if (!sf_getint ("dip0n", &dip0n) ) sf_error ("Need dip0n="); /* number of dip0 values (if adj=y) */ if (!sf_getfloat ("dip0d", &dip0d)) sf_error("Need dip0d="); /* dip0 sampling (if adj=y) */ if (!sf_getfloat("dip0o",&dip0o)) sf_error("Need dip0d0="); /* dip0 origin (if adj=y) */ if (!sf_getint ("sdip0n", &sdip0n) ) sf_error ("Need sdip0n="); /* number of sdip0 values (if adj=y) */ if (!sf_getfloat ("sdip0d", &sdip0d)) sf_error ("Need sdip0d="); /* sdip0 sampling (if adj=y) */ if (!sf_getfloat("sdip0o", &sdip0o)) sf_error ("Need sdip0d0="); /* sdip0 origin (if adj=y) */ // diffraction model if (!sf_getint ("xin", &xin) ) sf_error ("Need xin="); /* number of xi values (if adj=y) */ if (!sf_getfloat ("xid", &xid)) sf_error("Need xid="); /* xi sampling (if adj=y) */ if (!sf_getfloat("xio",&xio)) sf_error("Need xio="); /* xi origin (if adj=y) */ if (!sf_getint ("sxin", &sxin) ) sf_error ("Need sxin="); /* number of xi values (if adj=y) */ if (!sf_getfloat ("sxid", &sxid)) sf_error("Need sxid="); /* xi sampling (if adj=y) */ if (!sf_getfloat("sxio", &sxio)) sf_error("Need sxio="); /* xi origin (if adj=y) */ // diffraction-model file sf_putint (fileDiff, "n2", xin); sf_putfloat (fileDiff, "d2", xid); sf_putfloat (fileDiff, "o2", xio); sf_putstring (fileDiff, "label2", "xi"); sf_putstring (fileDiff, "unit2", ""); sf_putint (fileDiff, "n3", sxin); sf_putfloat (fileDiff, "d3", sxid); sf_putfloat (fileDiff, "o3", sxio); sf_putstring (fileDiff, "label3", "xi"); sf_putstring (fileDiff, "unit3", ""); // reflection-model file sf_putint (fileRefl, "n2", dip0n); sf_putfloat (fileRefl, "d2", dip0d); sf_putfloat (fileRefl, "o2", dip0o); sf_putstring (fileRefl, "label2", "dip angle"); sf_putstring (fileRefl, "unit2", "deg"); sf_putint (fileRefl, "n3", sdip0n); sf_putfloat (fileRefl, "d3", sdip0d); sf_putfloat (fileRefl, "o3", sdip0o); sf_putstring (fileRefl, "label3", "dip angle"); sf_putstring (fileRefl, "unit3", "deg"); } else { // model -> data fileDiff = in; fileRefl = sf_input ("reflMod"); // reflection model if ( !sf_histint (fileRefl, "n2", &dip0n) ) sf_error ("No n2= in reflection-model file"); if ( !sf_histfloat (fileRefl, "d2", &dip0d) ) sf_error ("No d2= in reflection-model file"); if ( !sf_histfloat (fileRefl, "o2", &dip0o) ) sf_error ("No o2= in reflection-model file"); if ( !sf_histint (fileRefl, "n3", &sdip0n) ) sf_error ("No n3= in reflection-model file"); if ( !sf_histfloat (fileRefl, "d3", &sdip0d) ) sf_error ("No d3= in reflection-model file"); if ( !sf_histfloat (fileRefl, "o3", &sdip0o) ) sf_error ("No o3= in reflection-model file"); // diffraction model if ( !sf_histint (fileDiff, "n2", &xin) ) sf_error ("No n2= in diffraction-model file"); if ( !sf_histfloat (fileDiff, "d2", &xid) ) sf_error ("No d2= in diffraction-model file"); if ( !sf_histfloat (fileDiff, "o2", &xio) ) sf_error ("No o2= in diffraction-model file"); if ( !sf_histint (fileDiff, "n3", &sxin) ) sf_error ("No n3= in diffraction-model file"); if ( !sf_histfloat (fileDiff, "d3", &sxid) ) sf_error ("No d3= in diffraction-model file"); if ( !sf_histfloat (fileDiff, "o3", &sxio) ) sf_error ("No o3= in diffraction-model file"); // run parameters if (!sf_getint ("dipn", &dipn)) sf_error ("Need dipn="); /* number of dips in x-direction */ if (!sf_getfloat ("dipo", &dipo)) sf_error ("Need dipo="); /* dip origin in x-direction */ if (!sf_getfloat ("dipd", &dipd)) sf_error ("Need dipd="); /* dip sampling in x-direction */ if (!sf_getint ("sdipn", &sdipn)) sf_error ("Need sdipn="); /* number of dips in y-direction */ if (!sf_getfloat ("sdipo", &sdipo)) sf_error ("Need sdipo="); /* dip origin in y-direction */ if (!sf_getfloat ("sdipd", &sdipd)) sf_error ("Need sdipd="); /* dip sampling in y-direction */ // output file sf_putint (out, "n2", dipn); sf_putfloat (out, "o2", dipo); sf_putfloat (out, "d2", dipd); sf_putstring (out, "label2", "x-dip angle"); sf_putstring (out, "unit2", "deg"); sf_putint (out, "n3", sdipn); sf_putfloat (out, "o3", sdipo); sf_putfloat (out, "d3", sdipd); sf_putstring (out, "label3", "y-dip angle"); sf_putstring (out, "unit3", "deg"); } // data size dataSize = tn * dipn * sdipn; // model sizes diffSize = tn * xin * sxin; reflSize = tn * dip0n * sdip0n; modelSize = -1; switch (invMod) { case 0: modelSize = diffSize; break; case 1: modelSize = reflSize; break; case 2: modelSize = diffSize + reflSize; break; } data = sf_floatalloc (dataSize); model = sf_floatalloc (modelSize); w = (0 == niter) ? NULL : sf_floatalloc (modelSize); p = (0 == niter) ? NULL : sf_floatalloc (modelSize); ditime3d_init (dipo, dipd, dipn, sdipo, sdipd, sdipn, xio, xid, xin, sxio, sxid, sxin, dip0o, dip0d, dip0n, sdip0o, sdip0d, sdip0n, to, td, tn, isAA, invMod); // main loop for (ix = 0; ix < dagNum; ++ix) { if (verb) sf_warning ("i=%d of %d", ix + 1, dagNum); // read data if (adj) { // data -> model sf_floatread (data, dataSize, in); dweight = sf_floatalloc (dataSize); if (fileDweight) { sf_floatread (dweight, dataSize, fileDweight); } else { for (id = 0; id < dataSize; ++id) dweight[id] = 1.f; } } else { // model -> data if (0 == invMod) { // difffraction sf_floatread (model, diffSize, fileDiff); } else if (1 == invMod) { // reflection sf_floatread (model, reflSize, fileRefl); } else { // diffraction + reflection sf_floatread (model, diffSize, fileDiff); sf_floatread (model + diffSize, reflSize, fileRefl); } } // perform transform if (!adj || 0 == niter) { ditime3d_lop (adj, false, modelSize, dataSize, model, data); } else { // initital model weights for (im = 0; im < modelSize; ++im) { w[im] = 1.f; } for (iter = 0; iter < niter; ++iter) { sf_solver_prec (ditime3d_lop, sf_cgstep, sf_copy_lop, modelSize, modelSize, dataSize, model, data, liter, eps, "verb", verb, "mwt", w, "xp", p, "wt", dweight, "end"); sf_cgstep_close (); for (im = 0; im < modelSize; ++im) { w[im] = fabsf (p[im]); /* weight for sparsity */ } } } // write result if (adj) { // data -> model if (0 == invMod) { // difffraction sf_floatwrite (model, diffSize, fileDiff); } else if (1 == invMod) { // reflection sf_floatwrite (model, reflSize, fileRefl); } else { // diffraction + reflection sf_floatwrite (model, diffSize, fileDiff); sf_floatwrite (model + diffSize, reflSize, fileRefl); } } else { // model -> data sf_floatwrite (data, dataSize, out); } } // finish ditime3d_close (); if (w) free (w); if (p) free (p); if (dweight) free (dweight); free (data); free (model); sf_fileclose (in); sf_fileclose (out); sf_fileclose (fileRefl); if (fileDweight) sf_fileclose (fileDweight); return 0; }
int main(int argc, char* argv[]) { bool adj, inv; int n, n2, i2, niter, nliter, iter; float *x, *y, *w, **a, **b, eps; sf_file in, out, mat1, mat2; sf_init(argc,argv); in = sf_input("in"); out = sf_output("out"); mat1 = sf_input("mat1"); mat2 = sf_input("mat2"); if (SF_FLOAT != sf_gettype(in) || SF_FLOAT != sf_gettype(mat1) || SF_FLOAT != sf_gettype(mat2)) sf_error("Need float input"); if (!sf_histint(in,"n1",&n)) sf_error("No n1= in input"); if (!sf_histint(in,"n2",&n2) || n2 != n) sf_error("Need n2=%d",n); n2 = n*n; if (!sf_getbool("adj",&adj)) adj=false; /* adjoint flag */ if (!sf_getbool("inv",&inv)) inv=false; /* inversion flag */ if (!sf_getint("niter",&niter)) niter=100; /* maximum number of iterations */ if (!sf_getfloat("eps",&eps)) eps=0.; /* regularization */ if (!sf_getint("nliter",&nliter)) nliter=1; /* number of nonlinear iterations */ a = sf_floatalloc2(n,n); b = sf_floatalloc2(n,n); x = sf_floatalloc(n2); y = sf_floatalloc(n2); w = sf_floatalloc(n2); kron_init(n,a,b); sf_floatread(x,n2,in); sf_floatread(a[0],n2,mat1); sf_floatread(b[0],n2,mat2); if (adj) { if (inv) { sf_weight_init(w); for (i2=0; i2 < n2; i2++) { w[i2] = 1.; } for (iter=0; iter < nliter; iter++) { sf_solver_prec (kron_lop, sf_cgstep, sf_weight_lop, n2, n2, n2, y, x, niter, eps, "verb", true, "end"); sf_cgstep_close(); for (i2=0; i2 < n2; i2++) { w[i2] = fabsf(y[i2]); } } } else { kron_lop(true,false,n2,n2,y,x); } } else { kron_lop(false,false,n2,n2,x,y); } sf_floatwrite(y,n2,out); /* p = sf_floatalloc(n2); sf_conjgrad_init(n2,n2,n2,n2,eps,FLT_EPSILON,true,false); sf_conjgrad(NULL,kron_lop,sf_copy_lop,p,y,x,niter); */ exit(0); }