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);
}
