int main(int argc, char*argv[])
{
sf_file in, out ;
int i1, i2, n1, n2, *v;
float o1, d1, **u;
char *l1, *u1;
sf_axis ax;
sf_init(argc, argv);
in = sf_input("in"); /* delay file (int) */
out = sf_output("out");
if(!sf_histint(in, "n1", &n2)) sf_error("n1 needed");
sf_shiftdim(in, out, 1);
if(!sf_getint("n1", &n1)) n1=1000; /* samples */
if(!sf_getfloat("o1", &o1)) o1=0.0; /* sampling interval */
if(!sf_getfloat("d1", &d1)) d1=0.004; /* original */
if((l1=sf_getstring("l1")) == NULL) l1="Time"; /* label "Time" */
if((u1=sf_getstring("u1")) == NULL) u1="s"; /* unit "s" */
ax = sf_maxa(n1, o1, d1);
sf_setlabel(ax, l1);
sf_setunit(ax, u1);
sf_oaxa(out, ax, 1);
sf_putint(out, "n2", n2);
sf_settype(out, SF_FLOAT);
v = sf_intalloc(n2);
u = sf_floatalloc2(n1, n2);
sf_intread(v, n2, in);
for(i2=0; i2<n2; i2++)
for(i1=0; i1<n1; i1++)
if(i1==v[i2]) u[i2][i1] = 1;
else u[i2][i1] = 0;
sf_floatwrite(u[0], n1*n2, out);
free(v);
free(u[0]);
free(u);
return 0;
}
int main(int argc, char* argv[])
{
bool verb,isreversed;
sf_file Fs,Fr,Fi; /* I/O files */
sf_axis az,ax,at,aa; /* cube axes */
int iz,ix,it;
int nz,nx,nt;
off_t iseek;
float **us=NULL,**ur=NULL,**ii=NULL;
float scale;
/*------------------------------------------------------------*/
/* init RSF */
sf_init(argc,argv);
/* OMP parameters */
#ifdef _OPENMP
omp_init();
#endif
if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */
if(! sf_getbool("isreversed",&isreversed)) isreversed=false; /* received wavefield */
Fs = sf_input ("in" );
Fr = sf_input ("ur" );
Fi = sf_output("out");
/*------------------------------------------------------------*/
/* read axes */
az=sf_iaxa(Fs,1); nz = sf_n(az);
ax=sf_iaxa(Fs,2); nx = sf_n(ax);
at=sf_iaxa(Fs,3); nt = sf_n(at);
aa=sf_maxa(1,0,1);
sf_setlabel(aa,"");
sf_setunit (aa,"");
if(verb) {
sf_raxa(az);
sf_raxa(ax);
sf_raxa(at);
}
/* write axes */
sf_oaxa(Fi,az,1);
sf_oaxa(Fi,ax,2);
sf_oaxa(Fi,aa,3);
/*------------------------------------------------------------*/
/* allocate work arrays */
ii = sf_floatalloc2(nz,nx);
us = sf_floatalloc2(nz,nx);
ur = sf_floatalloc2(nz,nx);
for (ix=0; ix<nx; ix++) {
for(iz=0; iz<nz; iz++) {
ii[ix][iz]=0.;
}
}
/*------------------------------------------------------------*/
if(isreversed) { /* receiver wavefield is reversed */
if(verb) fprintf(stderr,"nt\n");
for (it=0; it<nt; it++) {
if(verb) fprintf(stderr,"\b\b\b\b\b\b\b\b\b\b%04d",it);
sf_floatread(us[0],nz*nx,Fs);
sf_floatread(ur[0],nz*nx,Fr);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) \
private(ix,iz) \
shared (ii,us,ur,nx,nz)
#endif
for (ix=0; ix<nx; ix++) {
for(iz=0; iz<nz; iz++) {
ii[ix][iz] += us[ix][iz]*ur[ix][iz];
}
}
} /* it */
if(verb) fprintf(stderr,"\n");
} else { /* receiver wavefield is NOT reversed */
if(verb) fprintf(stderr,"nt\n");
for (it=0; it<nt; it++) {
if(verb) fprintf(stderr,"\b\b\b\b\b%d",(nt-it-1));
sf_floatread(us[0],nz*nx,Fs);
iseek=(off_t)(nt-1-it)*nz*nx*sizeof(float);
sf_seek(Fr,iseek,SEEK_SET);
sf_floatread(ur[0],nz*nx,Fr);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) \
private(ix,iz) \
shared (ii,us,ur,nx,nz)
#endif
for (ix=0; ix<nx; ix++) {
for(iz=0; iz<nz; iz++) {
ii[ix][iz] += us[ix][iz]*ur[ix][iz];
}
}
} /* it */
if(verb) fprintf(stderr,"\n");
} /* end "is reversed" */
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* scale image */
scale = 1./nt;
for (ix=0; ix<nx; ix++) {
for(iz=0; iz<nz; iz++) {
ii[ix][iz] *=scale;
}
}
/*------------------------------------------------------------*/
/* write image */
sf_floatwrite(ii[0],nx*nz,Fi);
/*------------------------------------------------------------*/
/* deallocate arrays */
free(*ii); free(ii);
free(*us); free(us);
free(*ur); free(ur);
/*------------------------------------------------------------*/
exit (0);
}
int main(int argc, char* argv[])
{
bool verb;
int nx,nz,nc,ic,iz,ix;
int ind=0;
float tmp;
float dx,dz,ox,oz;
pt2d *cc=NULL;
float **eps=NULL,**del,***out=NULL;
float x,y,lambda0,lambda1,lambda2,twoA;
float lm00,lm01,lm02,lm10,lm11,lm12,lm20,lm21,lm22;
float *a=NULL,*b=NULL,**llm=NULL;
sf_axis ax,az,ac;
sf_file Fin=NULL,Fdel=NULL, Fc=NULL,Fout=NULL;
/* init RSF */
sf_init(argc,argv);
if(! sf_getbool("verb",&verb)) verb=false;
Fin = sf_input ("in" );
Fdel= sf_input ("del" );
Fout = sf_output ("out" );
Fc = sf_input ("cc" ); /* sample locations */
/* input axes */
az = sf_iaxa(Fin,1); sf_setlabel(az,"z"); if(verb) sf_raxa(az);
ax = sf_iaxa(Fin,2); sf_setlabel(ax,"x"); if(verb) sf_raxa(ax);
nz = sf_n(az); dz = sf_d(az); oz = sf_o(az);
nx = sf_n(ax); dx = sf_d(ax); ox = sf_o(ax);
eps = sf_floatalloc2(nz,nx);
del = sf_floatalloc2(nz,nx);
sf_floatread(eps[0],nz*nx,Fin);
sf_floatread(del[0],nz*nx,Fdel);
/* CIP coordinates */
ac = sf_iaxa(Fc,2); sf_setlabel(ac,"cc"); sf_setunit(ac,"");
if(verb) sf_raxa(ac);
nc = sf_n(ac);
cc= (pt2d*) sf_alloc(nc,sizeof(*cc));
pt2dread1(Fc,cc,nc,2); /* read coordinates */
/* nc=3*/
/* output files*/
out = sf_floatalloc3(nz,nx,nc);
sf_oaxa(Fout,az,1);
sf_oaxa(Fout,ax,2);
sf_oaxa(Fout,ac,3);
nc=3;
a = sf_floatalloc(nc);
b = sf_floatalloc(nc);
llm = sf_floatalloc2(2,nc);
/*find sample indexes*/
for(ic=0; ic<nc; ic++) {
b[ic]=cc[ic].z; /*delta*/
a[ic]=cc[ic].x; /*epsilon*/
sf_warning("x%d=%f,z%d=%f: epsilon=%f delta=%f",ic,cc[ic].x,ic,cc[ic].z,a[ic],b[ic]);
}
/* a[0]=0.0; b[0]=0.0;*/
/* a[2]=0.65; b[2]=0.0; */
/* a[1]=0.0; b[1]=0.35;*/
/*matrix*/
twoA=(a[0]-a[2])*(b[1]-b[2])-(a[1]-a[2])*(b[0]-b[2]);
/* if(twoA<0) { */
/* tmp=a[1];a[1]=a[2];a[2]=tmp; */
/* tmp=b[1];b[1]=b[2];b[2]=tmp; */
/* } */
sf_warning("a=%f %f %f",a[0],a[1],a[2]);
sf_warning("b=%f %f %f",b[0],b[1],b[2]);
twoA=(a[0]-a[2])*(b[1]-b[2])-(a[1]-a[2])*(b[0]-b[2]);
llm[0][0]=a[1]*b[2]-a[2]*b[1]; llm[0][1]=b[1]-b[2]; llm[0][2]=a[2]-a[1];
llm[1][0]=a[2]*b[0]-a[0]*b[2]; llm[1][1]=b[2]-b[0]; llm[1][2]=a[0]-a[2];
llm[2][0]=a[0]*b[1]-a[1]*b[0]; llm[2][1]=b[0]-b[1]; llm[2][2]=a[1]-a[0];
sf_warning("");
sf_warning("%f %f %f",llm[0][0], llm[0][1], llm[0][2]);
sf_warning("%f %f %f",llm[1][0], llm[1][1], llm[1][2]);
sf_warning("%f %f %f",llm[2][0], llm[2][1], llm[2][2]);
sf_warning("area=%f",twoA);
lm00=a[1]*b[2]-a[2]*b[1]; lm01=b[1]-b[2]; lm02=a[2]-a[1];
lm10=a[2]*b[0]-a[0]*b[2]; lm11=b[2]-b[0]; lm12=a[0]-a[2];
lm20=a[0]*b[1]-a[1]*b[0]; lm21=b[0]-b[1]; lm22=a[1]-a[0];
sf_warning("");
sf_warning("%f %f %f",lm00, lm01, lm02);
sf_warning("%f %f %f",lm10, lm11, lm12);
sf_warning("%f %f %f",lm20, lm21, lm22);
/* find shape functions */
for (ic=0; ic<nc; ic++) {
for (ix=0; ix<nx; ix++) {
for(iz=0; iz<nz; iz++) {
out[ic][ix][iz]=0.;
}
}
}
if(twoA!=0){
for (ix=0; ix<nx; ix++) {
for(iz=0; iz<nz; iz++) {
x=eps[ix][iz];
y=del[ix][iz];
lambda0=lm00 + lm01*x + lm02*y;
lambda1=lm10 + lm11*x + lm12*y;
lambda2=lm20 + lm21*x + lm22*y;
out[0][ix][iz]=lambda0/twoA;
out[1][ix][iz]=lambda1/twoA;
out[2][ix][iz]=lambda2/twoA;
}
}
}
sf_floatwrite(out[0][0],nz*nx*nc,Fout);
}
int main(int argc, char* argv[])
{
bool verb;
bool adj;
bool anis;
sf_file Fcip=NULL; /* lag-domain CIPs */
sf_file Fang=NULL; /* angle-domain CIPs */
sf_file Fvel=NULL; /* velocity @ CIPs */
sf_file Fnor=NULL; /* normals @ CIPs */
sf_file Ftlt=NULL; /* tilt @ CIPs */
sf_file Fani=NULL; /* anisotropy @ CIPs */
sf_axis ahx,ahy,ahz,aht,ac,ath,aph,aps,aj;
int ihx,ihy,ihz,iht,ic,ith,iph;
/* angle parameters */
int nth,nph,nps,nhx,nhy,nhz,nht;
float oth,oph,ops,ohx,ohy,ohz,oht;
float dth,dph,dps,dhx,dhy,dhz,dht;
float phi;
float tht;
float psi;
float v_s,v_r;
float cosum,codif,sitovel;
/* arrays 1 2 3 4 */
float ****cip; /* nhx-nhy-nhz-nht */
float **ang; /* nph-nth */
float *vep; /* nc */
float *ves; /* nc */
float *eps=NULL; /* nc */
float *dlt=NULL; /* nc */
vc3d vv; /* azimuth reference vector */
vc3d *nn; /* normal vectors */
vc3d *tt=NULL; /* tilt vectors */
vc3d *aa; /* in-plane reference vector */
vc3d qq;
vc3d jk; /* temp vector */
float hx,hy,hz;
float tau; /* time lag */
int jht; /* tau axis index */
float fht; /* tau axis weight */
float ssn; /* slant-stack normalization */
float *ttipar;
/*-----------------------------------------------------------------*/
/* init RSF */
sf_init(argc,argv);
#ifdef _OPENMP
omp_init(); /* OMP parameters */
#endif
if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */
if(! sf_getbool("anis",&anis)) anis=false; /* anisotropy flag */
if(! sf_getbool("adj", &adj)) adj=true; /* adj flag */
/*
* ADJ: cip to ang
* FOR: ang to cip
*/
sf_warning("verb=%d",verb);
sf_warning("anis=%d",anis);
/* select anisotropy model */
if(anis) sf_warning("ANI model");
else sf_warning("ISO model");
if(adj) {
Fcip=sf_input ( "in"); /* CIP file */
Fang=sf_output("out"); /* ANG file */
} else {
Fcip=sf_output("out"); /* CIP file */
Fang=sf_input ("in"); /* ANG file */
}
Fvel=sf_input ("vel"); /* velocity file */
Fnor=sf_input ("nor"); /* normal vectors */
if(anis) {
Ftlt=sf_input ("tlt"); /* tilt vectors */
Fani=sf_input ("ani"); /* anisotropy */
}
aj = sf_maxa(1,0,1);
if(adj) {
/* input axes */
ahx = sf_iaxa(Fcip,1); sf_setlabel(ahx,"hx");
ahy = sf_iaxa(Fcip,2); sf_setlabel(ahy,"hy");
ahz = sf_iaxa(Fcip,3); sf_setlabel(ahz,"hz");
aht = sf_iaxa(Fcip,4); sf_setlabel(aht,"ht");
/* CIP axis */
ac = sf_iaxa(Fcip,5); sf_setlabel(ac ,"c ");
/* reflection angle */
if(! sf_getint ("nth",&nth)) nth=90;
if(! sf_getfloat("oth",&oth)) oth=0;
if(! sf_getfloat("dth",&dth)) dth=1.;
ath = sf_maxa(nth,oth,dth);
sf_setlabel(ath,"th");
sf_setunit (ath,"deg");
/* azimuth angle */
if(! sf_getint ("nph",&nph)) nph=360;
if(! sf_getfloat("oph",&oph)) oph=-180;
if(! sf_getfloat("dph",&dph)) dph=1.;
aph = sf_maxa(nph,oph,dph);
sf_setlabel(aph,"ph");
sf_setunit (aph,"deg");
/* output axes */
sf_oaxa(Fang,ath,1);
sf_oaxa(Fang,aph,2);
sf_oaxa(Fang,ac ,3);
sf_oaxa(Fang,aj ,4);
sf_oaxa(Fang,aj ,5);
} else {
/* lag in x */
if(! sf_getint ("nhx",&nhx)) nhx=1;
if(! sf_getfloat("ohx",&ohx)) ohx=0;
if(! sf_getfloat("dhx",&dhx)) dhx=1.;
ahx = sf_maxa(nhx,ohx,dhx);
sf_setlabel(ahx,"hx");
sf_setunit (ahx,"");
/* lag in y */
if(! sf_getint ("nhy",&nhy)) nhy=1;
if(! sf_getfloat("ohy",&ohy)) ohy=0;
if(! sf_getfloat("dhy",&dhy)) dhy=1.;
ahy = sf_maxa(nhy,ohy,dhy);
sf_setlabel(ahy,"hy");
sf_setunit (ahy,"");
/* lag in z */
nhz=1;
ohz=0.;
dhz=1.;
ahz = sf_maxa(nhz,ohz,dhz);
sf_setlabel(ahz,"hz");
sf_setunit (ahz,"");
/* lag in t */
if(! sf_getint ("nht",&nht)) nht=1;
if(! sf_getfloat("oht",&oht)) oht=0.;
if(! sf_getfloat("dht",&dht)) dht=1.;
aht = sf_maxa(nht,oht,dht);
sf_setlabel(aht,"ht");
sf_setunit (aht,"");
/* reflection angle */
ath = sf_iaxa(Fang,1); sf_setlabel(ath,"th");
/* azimuth angle */
aph = sf_iaxa(Fang,2); sf_setlabel(aph,"ph");
/* CIP axis */
ac = sf_iaxa(Fang,3); sf_setlabel(ac ,"c ");
/* output axes */
sf_oaxa(Fcip,ahx,1);
sf_oaxa(Fcip,ahy,2);
sf_oaxa(Fcip,ahz,3);
sf_oaxa(Fcip,aht,4);
sf_oaxa(Fcip,ac ,5);
}
if (verb){
sf_raxa(ahx);
sf_raxa(ahy);
sf_raxa(ahz);
sf_raxa(aht);
sf_raxa(ac);
sf_raxa(ath);
sf_raxa(aph);
}
if(anis) {
/* deviation angle */
if(! sf_getint ("nps",&nps)) nps=251;
if(! sf_getfloat("ops",&ops)) ops=-25;
if(! sf_getfloat("dps",&dps)) dps=0.2;
aps = sf_maxa(nps,ops,dps);
sf_setlabel(aps,"ps");
sf_setunit (aps,"deg");
if(verb) sf_raxa(aps);
} else {
aps = NULL;
}
/*------------------------------------------------------------*/
/* allocate arrays */
cip = sf_floatalloc4 (sf_n(ahx),sf_n(ahy),sf_n(ahz),sf_n(aht));
ang = sf_floatalloc2 (sf_n(ath),sf_n(aph));
/* read velocity */
vep = sf_floatalloc (sf_n(ac));
sf_floatread(vep,sf_n(ac),Fvel);
ves = sf_floatalloc (sf_n(ac));
sf_floatread(ves,sf_n(ac),Fvel);
/*------------------------------------------------------------*/
/* read normals */
nn = (vc3d*) sf_alloc(sf_n(ac),sizeof(*nn)); /* normals */
vc3dread1(Fnor,nn,sf_n(ac));
if(anis) {
/* read anisotropy */
eps = sf_floatalloc (sf_n(ac));
sf_floatread(eps,sf_n(ac),Fani);
dlt = sf_floatalloc (sf_n(ac));
sf_floatread(dlt,sf_n(ac),Fani);
/* read tilts */
tt = (vc3d*) sf_alloc(sf_n(ac),sizeof(*tt));
vc3dread1(Ftlt,tt,sf_n(ac));
}
/*------------------------------------------------------------*/
/* in-plane azimuth reference */
vv.dx=1;
vv.dy=0;
vv.dz=0;
aa = (vc3d*) sf_alloc(sf_n(ac),sizeof(*aa));
for(ic=0;ic<sf_n(ac);ic++) {
jk =vcp3d(&nn[ic],&vv);
aa[ic]=vcp3d(&jk,&nn[ic]);
}
/*------------------------------------------------------------*/
ssn = 1./sqrt(sf_n(ahx)*sf_n(ahy)*sf_n(ahz));
/*------------------------------------------------------------*/
/* loop over CIPs */
/* if(verb) fprintf(stderr,"ic\n");*/
for(ic=0;ic<sf_n(ac);ic++) {
/* if(verb) fprintf(stderr,"\b\b\b\b\b%d",ic);*/
if(adj) {
/* read CIP */
sf_floatread(cip[0][0][0],sf_n(ahx)*sf_n(ahy)*sf_n(ahz)*sf_n(aht),Fcip);
/* init ANG */
for (iph=0;iph<sf_n(aph);iph++) {
for(ith=0;ith<sf_n(ath);ith++) {
ang[iph][ith]=0;
}
}
} else {
/* init CIP */
for (iht=0;iht<sf_n(aht);iht++) {
for (ihz=0;ihz<sf_n(ahz);ihz++) {
for (ihy=0;ihy<sf_n(ahy);ihy++) {
for(ihx=0;ihx<sf_n(ahx);ihx++) {
cip[iht][ihz][ihy][ihx]=0;
}
}
}
}
/* read ANG */
sf_floatread(ang[0],sf_n(ath)*sf_n(aph),Fang);
}
/* phi loop */
nph = sf_n(aph);
#ifdef _OPENMP
#pragma omp parallel for schedule(static) \
private(iph,phi,jk,qq, \
ith,tht, \
ihy,ihx,hy,hx,hz, \
tau,jht,fht,cosum,codif,v_s,v_r,psi,sitovel) \
shared( nph,aph,ath,aps,ahy,ahx,aht,cip,ang,vep,ves,eps,dlt)
#endif
for(iph=0;iph<nph;iph++) {
phi=(180+sf_o(aph)+iph*sf_d(aph))/180.*SF_PI;
/* use '180' to reverse illumination direction: */
/* at a CIP, look toward the source */
/* reflection azimuth vector */
jk = rot3d(nn,aa,phi);
qq = nor3d(&jk);
/* theta loop */
for(ith=0;ith<sf_n(ath);ith++) {
tht=(sf_o(ath)+ith*sf_d(ath))/180.*SF_PI;
if(anis) {
ttipar = psitti(nn,&qq,tt,aa,
tht,phi,aps,
vep[ic],ves[ic],eps[ic],dlt[ic]);
psi = ttipar[0];
v_s = ttipar[1];
v_r = ttipar[2];
psi *= SF_PI/180.;
cosum = cosf(tht+psi);
codif = cosf(tht-psi);
sitovel = sinf(2*tht)/(v_s*cosum + v_r*codif);
} else {
sitovel = sinf(tht)/vep[ic];
}
/* lag loops */
if(adj) {
for (ihy=0;ihy<sf_n(ahy);ihy++) { hy=sf_o(ahy)+ihy*sf_d(ahy);
for(ihx=0;ihx<sf_n(ahx);ihx++) { hx=sf_o(ahx)+ihx*sf_d(ahx);
hz = -(hx*(nn[ic].dx)+hy*(nn[ic].dy))/(nn[ic].dz);
tau = -((qq.dx)*hx+(qq.dy)*hy+(qq.dz)*hz)*sitovel;
jht=0.5+(tau-sf_o(aht))/sf_d(aht);
if(jht>=0 && jht<sf_n(aht)-1) {
fht= (tau-sf_o(aht))/sf_d(aht)-jht;
ang[iph][ith] += (1-fht)*ssn*cip[jht ][0][ihy][ihx]
+ fht *ssn*cip[jht+1][0][ihy][ihx];
}
} /* hx */
} /* hy */
} else {
for (ihy=0;ihy<sf_n(ahy);ihy++) { hy=sf_o(ahy)+ihy*sf_d(ahy);
for(ihx=0;ihx<sf_n(ahx);ihx++) { hx=sf_o(ahx)+ihx*sf_d(ahx);
hz = -(hx*(nn[ic].dx)+hy*(nn[ic].dx))/(nn[ic].dz);
tau = -((qq.dx)*hx+(qq.dy)*hy+(qq.dz)*hz)*sitovel;
jht=0.5+(tau-sf_o(aht))/sf_d(aht);
if(jht>=0 && jht<sf_n(aht)-1) {
fht= (tau-sf_o(aht))/sf_d(aht)-jht;
cip[jht ][0][ihy][ihx] += (1-fht)*ssn*ang[iph][ith];
cip[jht+1][0][ihy][ihx] += fht *ssn*ang[iph][ith];
}
} /* hx */
} /* hy */
}
} /* th */
} /* ph */
if(adj) {
/* write ANG */
sf_floatwrite(ang[0],sf_n(ath)*sf_n(aph),Fang);
} else {
/* write CIP */
sf_floatwrite(cip[0][0][0],sf_n(ahx)*sf_n(ahy)*sf_n(ahz)*sf_n(aht),Fcip);
}
}
if(verb) fprintf(stderr,"\n");
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
if(verb) fprintf(stderr,"free memory...");
free(***cip);free(**cip);free(*cip);free(cip);
; free(*ang);free(ang);
; free(vep);
; free (nn);
; free (aa);
if(anis) {
free(ves);
free(eps);
free(dlt);
free(tt);
}
if(verb) fprintf(stderr,"OK\n");
/*------------------------------------------------------------*/
exit(0);
}
int main(int argc, char *argv[])
{
bool wantwf, verb;
int ix, iz, is, it, wfit, im, ik, i, j, itau;
int ns, nx, nz, nt, wfnt, rnx, rnz, nzx, rnzx, vnx, ntau, htau, nds;
int scalet, snap, snapshot, fnx, fnz, fnzx, nk, nb;
int rectx, rectz, repeat, gpz, n, m, pad1, trunc, spx, spz;
float dt, t0, z0, dz, x0, dx, s0, ds, wfdt, srctrunc;
float dtau, tau0, tau;
int nr, ndr, nr0;
char *path1, *path2, number[5], *left, *right;
double tstart, tend;
struct timeval tim;
/*wavenumber domain tapering*/
int taper;
float *ktp;
float ktmp,kx_trs,kz_trs,thresh;
float dkx,dkz,kx0,kz0;
float kx,kz;
int nkz;
sf_complex c, **lt, **rt;
sf_complex *ww, **dd, ***dd3;
float ***img1, **img2, ***mig1, **mig2;
float *rr, **ccr, **sill, ***fwf, ***bwf;
sf_complex *cwave, *cwavem, **wave, *curr;
sf_axis at, ax, az, atau;
sf_file Fdat, Fsrc, Fimg1, Fimg2;
sf_file Ffwf, Fbwf, Fvel;
sf_file Fleft, Fright;
int cpuid, numprocs, nth, nspad, iturn;
float *sendbuf, *recvbuf;
sf_complex *sendbufc, *recvbufc;
MPI_Comm comm=MPI_COMM_WORLD;
MPI_Init(&argc, &argv);
MPI_Comm_rank(comm, &cpuid);
MPI_Comm_size(comm, &numprocs);
sf_init(argc, argv);
#ifdef _OPENMP
#pragma omp parallel
{
nth=omp_get_num_threads();
}
sf_warning(">>> Using %d threads <<<", nth);
#endif
gettimeofday(&tim, NULL);
tstart=tim.tv_sec+(tim.tv_usec/1000000.0);
if (!sf_getint("taper",&taper)) taper=0; /* tapering in the frequency domain */
if (!sf_getfloat("thresh",&thresh)) thresh=0.92; /* tapering threshold */
if(!sf_getbool("wantwf", &wantwf)) wantwf=false;
if(!sf_getbool("verb", &verb)) verb=false;
if(!sf_getint("pad1", &pad1)) pad1=1;
/* padding factor on the first axis */
if(!sf_getint("nb", &nb)) sf_error("Need nb= ");
if(!sf_getfloat("srctrunc", &srctrunc)) srctrunc=0.4;
if(!sf_getint("rectx", &rectx)) rectx=2;
if(!sf_getint("rectz", &rectz)) rectz=2;
if(!sf_getint("repeat", &repeat)) repeat=2;
if(!sf_getint("scalet", &scalet)) scalet=1;
if(!sf_getint("snap", &snap)) snap=100;
/* interval of the output wavefield */
if(!sf_getint("snapshot", &snapshot)) snapshot=0;
/* print out the wavefield snapshots of this shot */
if(!sf_getint("nds", &nds)) sf_error("Need nds=!");
/* source and receiver positions */
if(!sf_getint("gpz", &gpz)) sf_error("Need gpz=");
if(!sf_getint("spx", &spx)) sf_error("Need spx=");
if(!sf_getint("spz", &spz)) sf_error("Need spz=");
/* tau parameters */
if(!sf_getint("ntau", &ntau)) sf_error("Need ntau=");
if(!sf_getfloat("dtau", &dtau)) sf_error("Need dtau=");
if(!sf_getfloat("tau0", &tau0)) sf_error("Need tau0=");
/* geometry parameters */
if(!sf_getint("rnx", &rnx)) sf_error("Need rnx=");
if(!sf_getint("ndr", &ndr)) ndr=1;
if(!sf_getint("nr0", &nr0)) nr0=0;
/* input/output files */
Fdat=sf_input("--input");
Fimg1=sf_output("--output");
Fimg2=sf_output("Fimg2");
Fsrc=sf_input("Fsrc");
Fvel=sf_input("Fpadvel");
if(wantwf){
Ffwf=sf_output("Ffwf");
Fbwf=sf_output("Fbwf");
}
at=sf_iaxa(Fsrc, 1); nt=sf_n(at); dt=sf_d(at); t0=sf_o(at);
ax=sf_iaxa(Fvel, 2); vnx=sf_n(ax); dx=sf_d(ax); x0=sf_o(ax);
az=sf_iaxa(Fvel, 1); rnz=sf_n(az); dz=sf_d(az); z0=sf_o(az);
if(!sf_histint(Fdat, "n2", &nr)) sf_error("Need n2= in input!");
if(!sf_histint(Fdat, "n3", &ns)) sf_error("Need n3= in input!");
if(!sf_histfloat(Fdat, "d3", &ds)) sf_error("Need d3= in input!");
if(!sf_histfloat(Fdat, "o3", &s0)) sf_error("Need o3= in input!");
wfnt=(nt-1)/scalet+1;
wfdt=dt*scalet;
/* double check the geometry parameters */
if(nds != (int)(ds/dx)) sf_error("Need ds/dx= %d", nds);
//sf_warning("s0=%g, x0+(rnx-1)*dx/2=%g", s0, x0+(rnx-1)*dx/2);
//if(s0 != x0+(rnx-1)*dx/2) sf_error("Wrong origin information!");
if(vnx != nds*(ns-1)+rnx) sf_error("Wrong dimension in x axis!");
/* set up the output files */
atau=sf_iaxa(Fsrc, 1);
sf_setn(atau, ntau);
sf_setd(atau, dtau);
sf_seto(atau, tau0);
sf_setlabel(atau, "Tau");
sf_setunit(atau, "s");
sf_oaxa(Fimg1, az, 1);
sf_oaxa(Fimg1, ax, 2);
sf_oaxa(Fimg1, atau, 3);
sf_oaxa(Fimg2, az, 1);
sf_oaxa(Fimg2, ax, 2);
sf_putint(Fimg2, "n3", 1);
sf_settype(Fimg1, SF_FLOAT);
sf_settype(Fimg2, SF_FLOAT);
if(wantwf){
sf_setn(ax, rnx);
sf_seto(ax, -(rnx-1)*dx/2.0);
sf_oaxa(Ffwf, az, 1);
sf_oaxa(Ffwf, ax, 2);
sf_putint(Ffwf, "n3", (wfnt-1)/snap+1);
sf_putfloat(Ffwf, "d3", snap*wfdt);
sf_putfloat(Ffwf, "o3", t0);
sf_putstring(Ffwf, "label3", "Time");
sf_putstring(Ffwf, "unit3", "s");
sf_settype(Ffwf, SF_FLOAT);
sf_oaxa(Fbwf, az, 1);
sf_oaxa(Fbwf, ax, 2);
sf_putint(Fbwf, "n3", (wfnt-1)/snap+1);
sf_putfloat(Fbwf, "d3", -snap*wfdt);
sf_putfloat(Fbwf, "o3", (wfnt-1)*wfdt);
sf_putstring(Fbwf, "label3", "Time");
sf_putstring(Fbwf, "unit3", "s");
sf_settype(Fbwf, SF_FLOAT);
}
nx=rnx+2*nb; nz=rnz+2*nb;
nzx=nx*nz; rnzx=rnz*rnx;
nk=cfft2_init(pad1, nz, nx, &fnz, &fnx);
fnzx=fnz*fnx;
if(ns%numprocs==0) nspad=ns;
else nspad=(ns/numprocs+1)*numprocs;
/* print axies parameters for double check */
sf_warning("cpuid=%d, numprocs=%d, nspad=%d", cpuid, numprocs, nspad);
sf_warning("nt=%d, dt=%g, scalet=%d, wfnt=%d, wfdt=%g",nt, dt, scalet, wfnt, wfdt);
sf_warning("vnx=%d, nx=%d, dx=%g, nb=%d, rnx=%d", vnx, nx, dx, nb, rnx);
sf_warning("nr=%d, ndr=%d, nr0=%g", nr, ndr, nr0);
sf_warning("nz=%d, rnz=%d, dz=%g, z0=%g", nz, rnz, dz, z0);
sf_warning("spx=%d, spz=%d, gpz=%d", spx, spz, gpz);
sf_warning("ns=%d, ds=%g, s0=%g", ns, ds, s0);
sf_warning("ntau=%d, dtau=%g, tau0=%g", ntau, dtau, tau0);
sf_warning("nzx=%d, fnzx=%d, nk=%d", nzx, fnzx, nk);
/* allocate storage and read data */
ww=sf_complexalloc(nt);
sf_complexread(ww, nt, Fsrc);
sf_fileclose(Fsrc);
gpz=gpz+nb;
spz=spz+nb;
spx=spx+nb;
nr0=nr0+nb;
trunc=srctrunc/dt+0.5;
dd=sf_complexalloc2(nt, nr);
if(cpuid==0) dd3=sf_complexalloc3(nt, nr, numprocs);
rr=sf_floatalloc(nzx);
reflgen(nz, nx, spz, spx, rectz, rectx, repeat, rr);
fwf=sf_floatalloc3(rnz, rnx, wfnt);
bwf=sf_floatalloc3(rnz, rnx, wfnt);
img1=sf_floatalloc3(rnz, vnx, ntau);
img2=sf_floatalloc2(rnz, vnx);
mig1=sf_floatalloc3(rnz, rnx, ntau);
mig2=sf_floatalloc2(rnz, rnx);
ccr=sf_floatalloc2(rnz, rnx);
sill=sf_floatalloc2(rnz, rnx);
curr=sf_complexalloc(fnzx);
cwave=sf_complexalloc(nk);
cwavem=sf_complexalloc(nk);
icfft2_allocate(cwavem);
if (taper!=0) {
dkz = 1./(fnz*dz); kz0 = -0.5/dz;
dkx = 1./(fnx*dx); kx0 = -0.5/dx;
nkz = fnz;
sf_warning("dkz=%f,dkx=%f,kz0=%f,kx0=%f",dkz,dkx,kz0,kx0);
sf_warning("nk=%d,nkz=%d,nkx=%d",nk,nkz,fnx);
kx_trs = thresh*fabs(0.5/dx);
kz_trs = thresh*fabs(0.5/dz);
sf_warning("Applying kz tapering below %f",kz_trs);
sf_warning("Applying kx tapering below %f",kx_trs);
ktp = sf_floatalloc(nk);
/* constructing the tapering op */
for (ix=0; ix < fnx; ix++) {
kx = kx0+ix*dkx;
for (iz=0; iz < nkz; iz++) {
kz = kz0+iz*dkz;
ktmp = 1.;
if (fabs(kx) > kx_trs)
ktmp *= powf((2*kx_trs - fabs(kx))/(kx_trs),2);
if (fabs(kz) > kz_trs)
ktmp *= powf((2*kz_trs - fabs(kz))/(kz_trs),2);
ktp[iz+ix*nkz] = ktmp;
}
}
}
/* initialize image tables that would be used for summing images */
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz, itau)
#endif
for(ix=0; ix<vnx; ix++){
for(iz=0; iz<rnz; iz++){
img2[ix][iz]=0.;
for(itau=0; itau<ntau; itau++){
img1[itau][ix][iz]=0.;
}
}
}
path1=sf_getstring("path1");
path2=sf_getstring("path2");
if(path1==NULL) path1="./mat/left";
if(path2==NULL) path2="./mat/right";
/* shot loop */
for (iturn=0; iturn*numprocs<nspad; iturn++){
is=iturn*numprocs+cpuid;
/* read data */
if(cpuid==0){
sf_seek(Fdat, ((off_t) is)*((off_t) nr)*((off_t) nt)*sizeof(float complex), SEEK_SET);
if((iturn+1)*numprocs<=ns){
sf_complexread(dd3[0][0], nr*nt*numprocs, Fdat);
}else{
sf_complexread(dd3[0][0], nr*nt*(ns-iturn*numprocs), Fdat);
for(is=ns; is<nspad; is++)
for(ix=0; ix<nr; ix++)
for(it=0; it<nt; it++)
dd3[is-iturn*numprocs][ix][it]=sf_cmplx(0.,0.);
is=iturn*numprocs;
}
sendbufc=dd3[0][0];
recvbufc=dd[0];
}else{
sendbufc=NULL;
recvbufc=dd[0];
}
MPI_Scatter(sendbufc, nt*nr, MPI_COMPLEX, recvbufc, nt*nr, MPI_COMPLEX, 0, comm);
if(is<ns){ /* effective shot loop */
/* construct the names of left and right matrices */
left=sf_charalloc(strlen(path1));
right=sf_charalloc(strlen(path2));
strcpy(left, path1);
strcpy(right, path2);
sprintf(number, "%d", is+1);
strcat(left, number);
strcat(right, number);
Fleft=sf_input(left);
Fright=sf_input(right);
if(!sf_histint(Fleft, "n1", &n) || n != nzx) sf_error("Need n1=%d in Fleft", nzx);
if(!sf_histint(Fleft, "n2", &m)) sf_error("No n2 in Fleft");
if(!sf_histint(Fright, "n1", &n) || n != m) sf_error("Need n1=%d in Fright", m);
if(!sf_histint(Fright, "n2", &n) || n != nk) sf_error("Need n2=%d in Fright", nk);
/* allocate storage for each shot migration */
lt=sf_complexalloc2(nzx, m);
rt=sf_complexalloc2(m, nk);
sf_complexread(lt[0], nzx*m, Fleft);
sf_complexread(rt[0], m*nk, Fright);
sf_fileclose(Fleft);
sf_fileclose(Fright);
/* initialize curr and imaging variables */
#ifdef _OPENMP
#pragma omp parallel for private(iz)
#endif
for(iz=0; iz<fnzx; iz++){
curr[iz]=sf_cmplx(0.,0.);
}
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz, itau)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
mig2[ix][iz]=0.;
ccr[ix][iz]=0.;
sill[ix][iz]=0.;
for(itau=0; itau<ntau; itau++){
mig1[itau][ix][iz]=0.;
}
}
}
/* wave */
wave=sf_complexalloc2(fnzx, m);
/* snapshot */
if(wantwf && is==snapshot) wantwf=true;
else wantwf=false;
/* forward propagation */
wfit=0;
for(it=0; it<nt; it++){
if(verb) sf_warning("Forward propagation it=%d/%d",it+1, nt);
cfft2(curr, cwave);
for(im=0; im<m; im++){
#ifdef _OPENMP
#pragma omp parallel for private(ik)
#endif
for(ik=0; ik<nk; ik++){
#ifdef SF_HAS_COMPLEX_H
cwavem[ik]=cwave[ik]*rt[ik][im];
#else
cwavem[ik]=sf_cmul(cwave[ik],rt[ik][im]);
#endif
}
icfft2(wave[im],cwavem);
}
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz, i, j, im, c) shared(curr, it)
#endif
for(ix=0; ix<nx; ix++){
for(iz=0; iz<nz; iz++){
i=iz+ix*nz;
j=iz+ix*fnz;
if(it<trunc){
#ifdef SF_HAS_COMPLEX_H
c=ww[it]*rr[i];
#else
c=sf_crmul(ww[it],rr[i]);
#endif
}else{
c=sf_cmplx(0.,0.);
}
// c += curr[j];
for(im=0; im<m; im++){
#ifdef SF_HAS_COMPLEX_H
c += lt[im][i]*wave[im][j];
#else
c += sf_cmul(lt[im][i], wave[im][j]);
#endif
}
curr[j]=c;
}
}
if (taper!=0) {
if (it%taper == 0) {
cfft2(curr,cwave);
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*ktp[ik];
#else
cwavem[ik] = sf_crmul(cwave[ik],ktp[ik]);
#endif
}
icfft2(curr,cwavem);
}
}
if(it%scalet==0){
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
fwf[wfit][ix][iz]=crealf(curr[(ix+nb)*fnz+(iz+nb)]);
}
}
wfit++;
}
} //end of it
/* check wfnt */
if(wfit != wfnt) sf_error("At this point, wfit should be equal to wfnt");
/* backward propagation starts from here... */
#ifdef _OPENMP
#pragma omp parallel for private(iz)
#endif
for(iz=0; iz<fnzx; iz++){
curr[iz]=sf_cmplx(0.,0.);
}
wfit=wfnt-1;
for(it=nt-1; it>=0; it--){
if(verb) sf_warning("Backward propagation it=%d/%d",it+1, nt);
#ifdef _OPENMP
#pragma omp parallel for private(ix)
#endif
for(ix=0; ix<nr; ix++){
curr[(nr0+ix*ndr)*fnz+gpz]+=dd[ix][it];
}
cfft2(curr, cwave);
for(im=0; im<m; im++){
#ifdef _OPENMP
#pragma omp parallel for private(ik)
#endif
for(ik=0; ik<nk; ik++){
#ifdef SF_HAS_COMPLEX_H
cwavem[ik]=cwave[ik]*conjf(rt[ik][im]);
#else
cwavem[ik]=sf_cmul(cwave[ik],conjf(rt[ik][im]));
#endif
}
icfft2(wave[im],cwavem);
}
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz, i, j, im, c) shared(curr, it)
#endif
for(ix=0; ix<nx; ix++){
for(iz=0; iz<nz; iz++){
i=iz+ix*nz;
j=iz+ix*fnz;
// c=curr[j];
c=sf_cmplx(0.,0.);
for(im=0; im<m; im++){
#ifdef SF_HAS_COMPLEX_H
c += conjf(lt[im][i])*wave[im][j];
#else
c += sf_cmul(conjf(lt[im][i]), wave[im][j]);
#endif
}
curr[j]=c;
}
}
if (taper!=0) {
if (it%taper == 0) {
cfft2(curr,cwave);
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*ktp[ik];
#else
cwavem[ik] = sf_crmul(cwave[ik],ktp[ik]);
#endif
}
icfft2(curr,cwavem);
}
}
if(it%scalet==0){
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
bwf[wfit][ix][iz]=crealf(curr[(ix+nb)*fnz+(iz+nb)]);
ccr[ix][iz] += fwf[wfit][ix][iz]*bwf[wfit][ix][iz];
sill[ix][iz] += fwf[wfit][ix][iz]*fwf[wfit][ix][iz];
}
}
wfit--;
}
} //end of it
if(wfit != -1) sf_error("Check program! The final wfit should be -1!");
/* free storage */
free(*rt); free(rt);
free(*lt); free(lt);
free(*wave); free(wave);
free(left); free(right);
/* normalized image */
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for (ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
mig2[ix][iz]=ccr[ix][iz]/(sill[ix][iz]+SF_EPS);
// sill[ix][iz]=0.;
}
}
/* time-shift imaging condition */
for(itau=0; itau<ntau; itau++){
//sf_warning("itau/ntau=%d/%d", itau+1, ntau);
tau=itau*dtau+tau0;
htau=tau/wfdt;
for(it=abs(htau); it<wfnt-abs(htau); it++){
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
mig1[itau][ix][iz]+=fwf[it+htau][ix][iz]*bwf[it-htau][ix][iz];
// sill[ix][iz]+=fwf[it+htau][ix][iz]*fwf[it+htau][ix][iz];
} // end of iz
} // end of ix
} // end of it
//#ifdef _OPENMP
//#pragma omp parallel for private(ix, iz)
//#endif
/* source illumination */
// for(ix=0; ix<rnx; ix++){
// for(iz=0; iz<rnz; iz++){
// mig1[itau][ix][iz] = mig1[itau][ix][iz]/(sill[ix][iz]+SF_EPS);
// }
// }
} //end of itau
/* output wavefield snapshot */
if(wantwf){
for(it=0; it<wfnt; it++){
if(it%snap==0){
sf_floatwrite(fwf[it][0], rnzx, Ffwf);
sf_floatwrite(bwf[wfnt-1-it][0], rnzx, Fbwf);
}
}
sf_fileclose(Ffwf);
sf_fileclose(Fbwf);
}
/* add all the shot images that are on the same node */
#ifdef _OPENMP
#pragma omp parallel for private(itau, ix, iz)
#endif
for(itau=0; itau<ntau; itau++){
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
img1[itau][ix+is*nds][iz] += mig1[itau][ix][iz];
}
}
}
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
img2[ix+is*nds][iz] += mig2[ix][iz];
}
}
} // end of is<ns
} // end of iturn
////////////////end of ishot
MPI_Barrier(comm);
cfft2_finalize();
sf_fileclose(Fdat);
free(ww); free(rr);
free(*dd); free(dd);
if(cpuid==0) {free(**dd3); free(*dd3); free(dd3);}
free(cwave); free(cwavem); free(curr);
free(*ccr); free(ccr);
free(*sill); free(sill);
free(**fwf); free(*fwf); free(fwf);
free(**bwf); free(*bwf); free(bwf);
free(**mig1); free(*mig1); free(mig1);
free(*mig2); free(mig2);
/* sum image */
if(cpuid==0){
sendbuf=(float *)MPI_IN_PLACE;
recvbuf=img1[0][0];
}else{
sendbuf=img1[0][0];
recvbuf=NULL;
}
MPI_Reduce(sendbuf, recvbuf, ntau*vnx*rnz, MPI_FLOAT, MPI_SUM, 0, comm);
if(cpuid==0){
sendbuf=MPI_IN_PLACE;
recvbuf=img2[0];
}else{
sendbuf=img2[0];
recvbuf=NULL;
}
MPI_Reduce(sendbuf, recvbuf, vnx*rnz, MPI_FLOAT, MPI_SUM, 0, comm);
/* output image */
if(cpuid==0){
sf_floatwrite(img1[0][0], ntau*vnx*rnz, Fimg1);
sf_floatwrite(img2[0], vnx*rnz, Fimg2);
}
MPI_Barrier(comm);
sf_fileclose(Fimg1);
sf_fileclose(Fimg2);
free(**img1); free(*img1); free(img1);
free(*img2); free(img2);
gettimeofday(&tim, NULL);
tend=tim.tv_sec+(tim.tv_usec/1000000.0);
sf_warning(">> The computing time is %.3lf minutes <<", (tend-tstart)/60.);
MPI_Finalize();
exit(0);
}
int main (int argc, char *argv[])
{
int adj; /* forward or adjoint */
int eic; /* EIC or CIC */
bool verb; /* verbosity */
float eps; /* dip filter constant */
int nrmax; /* number of reference velocities */
float dtmax; /* time error */
int pmx,pmy; /* padding in the k domain */
int tmx,tmy; /* boundary taper size */
int nhx, nhy, nhz, nht, nc;
int nhx2,nhy2,nhz2,nht2;
float dht, oht;
sf_axis amx,amy,az;
sf_axis alx,aly;
sf_axis aw,ae,ac,aa;
sf_axis ahx,ahy,ahz,aht;
/* I/O files */
sf_file Bws=NULL; /* background wavefield file Bws */
sf_file Bwr=NULL; /* background wavefield file Bwr */
sf_file Bs=NULL; /* background slowness file Bs */
sf_file Ps=NULL; /* slowness perturbation file Ps */
sf_file Pi=NULL; /* image perturbation file Pi */
sf_file Fc=NULL; /* CIP coordinates */
sf_file Pws=NULL; /* perturbed wavefield file Pws */
sf_file Pwr=NULL; /* perturbed wavefield file Pwr */
sf_file Pti=NULL;
int ompnth=1;
wexcub3d cub; /* wavefield hypercube */
wexcip3d cip; /* CIP gathers */
wextap3d tap; /* tapering */
wexssr3d ssr; /* SSR operator */
wexlsr3d lsr; /* LSR operator */
wexslo3d slo; /* slowness */
wexmvaop3d mva;
float dsmax;
/*------------------------------------------------------------*/
sf_init(argc,argv);
/* OMP parameters */
#ifdef _OPENMP
ompnth=omp_init();
#endif
if (!sf_getbool( "verb",&verb )) verb = true; /* verbosity flag */
if (!sf_getint( "adj",&adj )) sf_error("Specify adjoint!"); /* y=ADJ Back-projection; n=FWD Forward Scattering */
if (!sf_getint( "feic",&eic )) sf_error("Specify EIC!"); /* extended I.C. flag */
if (!sf_getfloat( "eps",&eps )) eps = 0.01; /* stability parameter */
if (!sf_getint( "nrmax",&nrmax)) nrmax = 1; /* max number of refs */
if (!sf_getfloat("dtmax",&dtmax)) dtmax = 0.004; /* max time error */
if (!sf_getint( "pmx",&pmx )) pmx = 0; /* padding on x */
if (!sf_getint( "pmy",&pmy )) pmy = 0; /* padding on y */
if (!sf_getint( "tmx",&tmx )) tmx = 0; /* taper on x */
if (!sf_getint( "tmy",&tmy )) tmy = 0; /* taper on y */
ae = sf_maxa(1,0,1);
nhx=nhy=nhz=nht=nc=nhx2=nhy2=nhz2=nht2=0;
oht = dht = 0.0;
/*------------------------------------------------------------*/
/* slowness */
Bs = sf_input("slo");
alx = sf_iaxa(Bs,1); sf_setlabel(alx,"lx");
aly = sf_iaxa(Bs,2); sf_setlabel(aly,"ly");
az = sf_iaxa(Bs,3); sf_setlabel(az, "z");
/*------------------------------------------------------------*/
/* input file */
if(adj)
Pi = sf_input("in");
else
Ps = sf_input("in");
/*------------------------------------------------------------*/
/* wavefield */
Bws = sf_input("swfl");
Bwr = sf_input("rwfl");
amx = sf_iaxa(Bws,1); sf_setlabel(amx,"mx");
amy = sf_iaxa(Bws,2); sf_setlabel(amy,"my");
aw = sf_iaxa(Bws,4); sf_setlabel(aw ,"w" );
Pws = sf_tmpfile(NULL); sf_settype(Pws,SF_COMPLEX);
Pwr = sf_tmpfile(NULL); sf_settype(Pwr,SF_COMPLEX);
/*------------------------------------------------------------*/
cub = wex_cube(verb,
amx,amy,az,
alx,aly,
aw,
ae,
eps,
ompnth);
dsmax = dtmax/cub->az.d;
/*------------------------------------------------------------*/
/* init structures */
tap = wextap_init(cub->amx.n,
cub->amy.n,
1,
SF_MIN(tmx,cub->amx.n-1), /* tmx */
SF_MIN(tmy,cub->amy.n-1), /* tmy */
0,
true,true,false);
slo = wexslo_init(cub,Bs,nrmax,dsmax);
ssr = wexssr_init(cub,slo,pmx,pmy,tmx,tmy,dsmax);
lsr = wexlsr_init(cub,pmx,pmy,dsmax);
/*------------------------------------------------------------*/
Pti = sf_tmpfile(NULL); sf_settype(Pti,SF_COMPLEX);
/*------------------------------------------------------------*/
/* WEMVA */
if(adj) {
sf_warning("adjoint operator...");
if(eic){
ahx = sf_iaxa(Pi,1); sf_setlabel(ahx,"hx");
ahy = sf_iaxa(Pi,2); sf_setlabel(ahy,"hy");
ahz = sf_iaxa(Pi,3); sf_setlabel(ahz,"hz");
aht = sf_iaxa(Pi,4); sf_setlabel(aht,"ht");
dht = sf_d(aht); oht = sf_o(aht);
nhx2 = sf_n(ahx); nhx = (nhx2-1)/2;
nhy2 = sf_n(ahy); nhy = (nhy2-1)/2;
nhz2 = sf_n(ahz); nhz = (nhz2-1)/2;
nht2 = sf_n(aht); nht = (nht2-1)/2;
/* CIP coordinates */
Fc = sf_input ("cc" );
ac = sf_iaxa(Fc,2); sf_setlabel(ac,"cc"); sf_setunit(ac,"");
nc = sf_n(ac);
}
cip = wexcip_init(cub,nhx,nhy,nhz,nht,nhx2,nhy2,nhz2,nht2,nc,dht,oht,Fc,eic);
mva = wexmva_init(cub,cip);
Ps = sf_output("out"); sf_settype(Ps,SF_COMPLEX);
sf_oaxa(Ps,amx,1);
sf_oaxa(Ps,amy,2);
sf_oaxa(Ps,az, 3);
if(eic){
sf_oaxa(Ps,ae, 4);
sf_oaxa(Ps,ae, 5);}
/* Adjoint I.C. operator, dI -> dW */
wexcip_adj(cub,cip,Bwr,Pws,Pi,eic,1,1); /* Ws dR */
wexcip_adj(cub,cip,Bws,Pwr,Pi,eic,0,0); /* Wr dR */
sf_filefresh(Pws);
sf_filefresh(Pwr);
/* Adjoint WEMVA operator, dW -> dS */
wexmva(mva,adj,cub,ssr,lsr,tap,slo,Bws,Bwr,Pws,Pwr,Ps);
} else {
/* set up the I/O of output CIP gathers */
Pi = sf_output("out"); sf_settype(Pi,SF_COMPLEX);
if(eic){
/* CIP coordinates */
Fc = sf_input ("cc" );
ac = sf_iaxa(Fc,2); sf_setlabel(ac,"cc"); sf_setunit(ac,"");
nc = sf_n(ac);
if(! sf_getint("nhx",&nhx)) nhx=0; /* number of lags on the x axis */
if(! sf_getint("nhy",&nhy)) nhy=0; /* number of lags on the y axis */
if(! sf_getint("nhz",&nhz)) nhz=0; /* number of lags on the z axis */
if(! sf_getint("nht",&nht)) nht=0; /* number of lags on the t axis */
if(! sf_getfloat("dht",&dht)) sf_error("need dht");
oht = -nht*dht;
nhx2=2*nhx+1; nhy2=2*nhy+1;
nhz2=2*nhz+1; nht2=2*nht+1;
aa=sf_maxa(nhx2,-nhx*cub->amx.d,cub->amx.d);
sf_setlabel(aa,"hx"); sf_setunit(aa,"");
if(verb) sf_raxa(aa);
sf_oaxa(Pi,aa,1);
aa=sf_maxa(nhy2,-nhy*cub->amy.d,cub->amy.d);
sf_setlabel(aa,"hy"); sf_setunit(aa,"");
if(verb) sf_raxa(aa);
sf_oaxa(Pi,aa,2);
aa=sf_maxa(nhz2,-nhz*cub->az.d,cub->az.d);
sf_setlabel(aa,"hz"); sf_setunit(aa,"");
if(verb) sf_raxa(aa);
sf_oaxa(Pi,aa,3);
aa=sf_maxa(nht2,-nht*dht,dht);
sf_setlabel(aa,"ht"); sf_setunit(aa,"s");
if(verb) sf_raxa(aa);
sf_oaxa(Pi,aa,4);
sf_oaxa(Pi,ac,5);
}
else{
sf_oaxa(Pi,amx,1);
sf_oaxa(Pi,amy,2);
sf_oaxa(Pi,az, 3);
}
cip = wexcip_init(cub,nhx,nhy,nhz,nht,nhx2,nhy2,nhz2,nht2,nc,dht,oht,Fc,eic);
mva = wexmva_init(cub,cip);
/* WEMVA operator, dS -> dW */
wexmva(mva,adj,cub,ssr,lsr,tap,slo,Bws,Bwr,Pws,Pwr,Ps);
sf_filefresh(Pws);
sf_filefresh(Pwr);
/* I.C. operator, dW -> dI */
wexcip_for(cub,cip,Bws,Pwr,Pti,eic,0,0); /* CONJ( Ws) dWr */
sf_seek(Pti,(off_t)0,SEEK_SET);
wexcip_for(cub,cip,Pws,Bwr,Pti,eic,0,1); /* CONJ(dWs) Wr */
sf_filefresh(Pti);
sf_filecopy(Pi,Pti,SF_COMPLEX);
}
/*------------------------------------------------------------*/
/* close structures */
wexslo_close(slo);
wexssr_close(cub,ssr);
wextap2D_close(tap);
wexmva_close(mva);
wexcip_close(cip,eic);
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* close files */
if (Ps!=NULL) sf_fileclose(Ps);
if (Fc!=NULL) sf_fileclose(Fc);
if (Pi!=NULL) sf_fileclose(Pi);
if (Bws!=NULL) sf_fileclose(Bws);
if (Bwr!=NULL) sf_fileclose(Bwr);
if (Pws!=NULL) sf_tmpfileclose(Pws);
if (Pwr!=NULL) sf_tmpfileclose(Pwr);
if (Pti!=NULL) sf_tmpfileclose(Pti);
/*------------------------------------------------------------*/
exit (0);
}
int main(int argc, char* argv[])
{
bool verb,isreversed;
sf_file Fs,Fr,Fi,Fc; /* I/O files */
sf_axis az,ax,at,ac,aa; /* cube axes */
int nz,nx,nt, nhx, nhz, nht,nc;
int it, ihx, ihz, iht,ic;
int nhx2,nhz2,nht2;
off_t iseek;
float ***us=NULL,***ur=NULL,****ii=NULL;
pt2d *cc=NULL;
bool *ccin=NULL;
float cxmin,czmin;
float cxmax,czmax;
int icx, icz;
int mcx, mcz, mct;
int pcx, pcz, pct;
int **mcxall, **pcxall;
int **mczall, **pczall;
int *mctall, *pctall;
int lht;
float scale;
/* gaussian taper */
bool gaus;
float gsx,gsz,gst; /* std dev */
float gx, gz, gt;
/*------------------------------------------------------------*/
/* init RSF */
sf_init(argc,argv);
/* OMP parameters */
#ifdef _OPENMP
omp_init();
#endif
if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */
if(! sf_getbool("isreversed",&isreversed)) isreversed=false; /* reversed rec wfld? */
Fs = sf_input ("in" ); /* source wavefield */
Fr = sf_input ("ur" ); /* receiver wavefield */
Fc = sf_input ("cc" ); /* CIP coordinates */
Fi = sf_output("out"); /* image */
/*------------------------------------------------------------*/
/* read axes */
az=sf_iaxa(Fs,1); nz = sf_n(az);
ax=sf_iaxa(Fs,2); nx = sf_n(ax);
at=sf_iaxa(Fs,3); nt = sf_n(at);
/* CIP coordinates */
ac = sf_iaxa(Fc,2); sf_setlabel(ac,"cc"); sf_setunit(ac,"");
nc = sf_n(ac);
if(! sf_getint("nhz",&nhz)) nhz=0; nhz2=2*nhz+1; /* z lags */
if(! sf_getint("nhx",&nhx)) nhx=0; nhx2=2*nhx+1; /* x lags */
if(! sf_getint("nht",&nht)) nht=0; nht2=2*nht+1; /* t lags */
lht=2*nht;
if(verb) {
sf_warning("nhx=%3d nhz=%3d nht=%3d",nhx2,nhz2,nht2);
sf_raxa(az);
sf_raxa(ax);
sf_raxa(at);
sf_raxa(ac);
}
/* set output axes */
aa=sf_maxa(nhz2,-nhz*sf_d(az),sf_d(az));
sf_setlabel(aa,"hz"); sf_setunit(aa,"");
if(verb) sf_raxa(aa);
sf_oaxa(Fi,aa,1);
aa=sf_maxa(nhx2,-nhx*sf_d(ax),sf_d(ax));
sf_setlabel(aa,"hx"); sf_setunit(aa,"");
if(verb) sf_raxa(aa);
sf_oaxa(Fi,aa,2);
aa=sf_maxa(nht2,-nht*sf_d(at),sf_d(at));
sf_setlabel(aa,"ht"); sf_setunit(aa,"");
if(verb) sf_raxa(aa);
sf_oaxa(Fi,aa,3);
sf_oaxa(Fi,ac,4);
if(! sf_getbool("gaus",&gaus)) gaus=false; /* Gaussian taper flag */
if(gaus) {
if(! sf_getfloat("gsx",&gsx)) gsx=nhx*sf_d(ax); gsx=1./(2*gsx*gsx);
if(! sf_getfloat("gsz",&gsz)) gsz=nhz*sf_d(az); gsz=1./(2*gsz*gsz);
if(! sf_getfloat("gst",&gst)) gst=nht*sf_d(at); gst=1./(2*gst*gst);
}
/*------------------------------------------------------------*/
/* allocate work arrays */
us=sf_floatalloc3(nz,nx,nht2);
ur=sf_floatalloc3(nz,nx,nht2);
ii=sf_floatalloc4(nhz2,nhx2,nht2,nc);
/* zero output */
for(ic=0; ic<nc; ic++) {
for (iht=0; iht<nht2; iht++) {
for (ihx=0; ihx<nhx2; ihx++) {
for(ihz=0; ihz<nhz2; ihz++) {
ii[ic][iht][ihx][ihz] = 0;
}
}
}
}
/*------------------------------------------------------------*/
/* CIP coordinates */
cc= (pt2d*) sf_alloc(nc,sizeof(*cc));
pt2dread1(Fc,cc,nc,2);
mcxall=sf_intalloc2(nhx2,nc);
pcxall=sf_intalloc2(nhx2,nc);
mczall=sf_intalloc2(nhz2,nc);
pczall=sf_intalloc2(nhz2,nc);
ccin=sf_boolalloc(nc);
cxmin = sf_o(ax) + nhx *sf_d(ax);
cxmax = sf_o(ax) + (sf_n(ax)-1-nhx)*sf_d(ax);
czmin = sf_o(az) + nhz *sf_d(az);
czmax = sf_o(az) + (sf_n(az)-1-nhz)*sf_d(az);
if(verb) {
sf_warning("cxmin=%f,cxmax=%f",cxmin,cxmax);
sf_warning("czmin=%f,czmax=%f",czmin,czmax);
}
for(ic=0; ic<nc; ic++) {
ccin[ic]=(cc[ic].x>=cxmin && cc[ic].x<=cxmax &&
cc[ic].z>=czmin && cc[ic].z<=czmax)?true:false;
if(ccin[ic]) {
icx = 0.5+(cc[ic].x-sf_o(ax))/sf_d(ax);
for(ihx=-nhx; ihx<nhx+1; ihx++) {
mcxall[ic][nhx+ihx] = icx-ihx;
pcxall[ic][nhx+ihx] = icx+ihx;
}
icz = 0.5+(cc[ic].z-sf_o(az))/sf_d(az);
for(ihz=-nhz; ihz<nhz+1; ihz++) {
mczall[ic][nhz+ihz] = icz-ihz;
pczall[ic][nhz+ihz] = icz+ihz;
}
}
}
mctall=sf_intalloc(nht2);
pctall=sf_intalloc(nht2);
for (iht=0; iht<nht2; iht++) {
mctall[iht]=iht;
pctall[iht]=2*nht-iht;
}
/*------------------------------------------------------------*/
if(isreversed) { /* receiver wavefield is reversed */
/* read wavefield @ [0...2nht-1]*/
for(iht=0;iht<2*nht;iht++) {
sf_floatread(us[iht][0],nz*nx,Fs);
sf_floatread(ur[iht][0],nz*nx,Fr);
}
if(verb) fprintf(stderr,"nt\n");
for(it=nht;it<nt-nht;it++) {
if(verb) fprintf(stderr,"\b\b\b\b\b\b\b\b\b\b%04d",it);
/* read wavefield @ [2nht]*/
sf_floatread(us[ lht ][0],nz*nx,Fs);
sf_floatread(ur[ lht ][0],nz*nx,Fr);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) \
private(ic, \
ihx,ihz,iht, \
mcx,mcz,mct, \
pcx,pcz,pct) \
shared (nc,ii,us,ur, \
nhx2, nhz2, nht2, \
mcxall,mczall,mctall, \
pcxall,pczall,pctall,ccin)
#endif
for(ic=0; ic<nc; ic++) {
if(ccin[ic]) {
for (iht=0; iht<nht2; iht++) { mct=mctall [iht]; pct=pctall [iht];
for (ihx=0; ihx<nhx2; ihx++) { mcx=mcxall[ic][ihx]; pcx=pcxall[ic][ihx];
for(ihz=0; ihz<nhz2; ihz++) { mcz=mczall[ic][ihz]; pcz=pczall[ic][ihz];
ii[ic][iht][ihx][ihz] += us[mct][mcx][mcz]*ur[pct][pcx][pcz];
} /* ihz */
} /* ihx */
} /* iht */
}
} /* ic */
/* update wavefield index (cycle) */
for(iht=0;iht<nht2;iht++) {
mctall[iht] = (mctall[iht]+1) % nht2;
pctall[iht] = (pctall[iht]+1) % nht2;
}
lht = (lht+1) % nht2;
} /* it */
if(verb) fprintf(stderr,"\n");
} else { /* receiver wavefield is NOT reversed */
/* read wavefield @ [0...2nht-1]*/
for(iht=0;iht<2*nht;iht++) {
sf_floatread(us[iht][0],nz*nx,Fs);
iseek = (off_t)(nt-1-iht)*nz*nx*sizeof(float);
sf_seek(Fr,iseek,SEEK_SET);
sf_floatread(ur[iht][0],nz*nx,Fr);
}
if(verb) fprintf(stderr,"nt\n");
for(it=nht;it<nt-nht;it++) {
if(verb) fprintf(stderr,"\b\b\b\b\b\b\b\b\b\b%04d",nt-nht-1-it);
/* read wavefield @ [2nht]*/
sf_floatread(us[ lht ][0],nz*nx,Fs);
iseek=(off_t)(nt-nht-1-it)*nz*nx*sizeof(float);
sf_seek(Fr,iseek,SEEK_SET);
sf_floatread(ur[ lht ][0],nz*nx,Fr);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) \
private(ic, \
ihx,ihz,iht, \
mcx,mcz,mct, \
pcx,pcz,pct) \
shared (nc,ii,us,ur, \
nhx2, nhz2, nht2, \
mcxall,mczall,mctall, \
pcxall,pczall,pctall,ccin)
#endif
for(ic=0; ic<nc; ic++) {
if(ccin[ic]) {
for (iht=0; iht<nht2; iht++) { mct=mctall [iht]; pct=pctall [iht];
for (ihx=0; ihx<nhx2; ihx++) { mcx=mcxall[ic][ihx]; pcx=pcxall[ic][ihx];
for(ihz=0; ihz<nhz2; ihz++) { mcz=mczall[ic][ihz]; pcz=pczall[ic][ihz];
ii[ic][iht][ihx][ihz] += us[mct][mcx][mcz]*ur[pct][pcx][pcz];
} /* ihz */
} /* ihx */
} /* iht */
}
} /* ic */
/* update wavefield index (cycle) */
for(iht=0;iht<nht2;iht++) {
mctall[iht] = (mctall[iht]+1) % nht2;
pctall[iht] = (pctall[iht]+1) % nht2;
}
lht = (lht+1) % nht2;
} /* it */
if(verb) fprintf(stderr,"\n");
} /* end "is reversed" */
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* scale image */
scale = 1./nt;
for(ic=0; ic<nc; ic++) {
for (iht=0; iht<nht2; iht++) {
for (ihx=0; ihx<nhx2; ihx++) {
for(ihz=0; ihz<nhz2; ihz++) {
ii[ic][iht][ihx][ihz] *= scale;
}
}
}
}
/*------------------------------------------------------------*/
/* apply Gaussian taper */
if(gaus) {
for(ic=0; ic<nc; ic++) {
for (iht=0;iht<nht2;iht++) { gt=(iht-nht)*sf_d(at); gt*=gt;
for (ihx=0;ihx<nhx2;ihx++) { gx=(ihx-nhx)*sf_d(ax); gx*=gx;
for(ihz=0;ihz<nhz2;ihz++) { gz=(ihz-nhz)*sf_d(az); gz*=gz;
ii[ic][iht][ihx][ihz] *= exp(-gt*gst - gx*gsx - gz*gsz);
}
}
}
}
}
/*------------------------------------------------------------*/
/* write image */
sf_floatwrite(ii[0][0][0],nc*(nhx2)*(nhz2)*(nht2),Fi);
/*------------------------------------------------------------*/
/* deallocate arrays */
free(***ii); free(**ii); free(*ii); free(ii);
free(*us); free(us);
free(*ur); free(ur);
free(cc);
free(ccin);
free(*mcxall); free(mcxall);
free(*pcxall); free(pcxall);
free(*mczall); free(mczall);
free(*pczall); free(pczall);
/*------------------------------------------------------------*/
exit (0);
}
int main(int argc, char* argv[])
{
bool verb,adj;
/* I/O files */
sf_file Ftrc=NULL; /* traces */
sf_file Fcoo=NULL; /* coordinates */
sf_file Fwfl=NULL; /* wavefield */
/* cube axes */
sf_axis at,az,ax,aa,ac;
/* I/O arrays */
float *wco=NULL; /* traces */
pt2d *coo=NULL; /* coordinates */
lint2d cow; /* weights/indices */
float **wfl=NULL; /* wavefield */
fdm2d fdm=NULL;
int iz,ix,it;
int nz,nx;
float dz,dx;
float oz,ox;
/*------------------------------------------------------------*/
/* init RSF */
sf_init(argc,argv);
/*------------------------------------------------------------*/
if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */
if(! sf_getbool("adj", &adj)) adj=false; /* adjoint flag */
/*------------------------------------------------------------*/
/* setup I/O */
Fcoo = sf_input("coo"); /* coordinates */
ac = sf_iaxa(Fcoo,2); sf_setlabel(ac,"c"); sf_setunit(ac,"");
coo = (pt2d*) sf_alloc(sf_n(ac),sizeof(*coo));
pt2dread1(Fcoo,coo,sf_n(ac),2); /* read (x,z) coordinates */
if(adj) {
Fwfl = sf_input ("in"); /* wavefield */
Ftrc = sf_output("out"); /* traces */
az = sf_iaxa(Fwfl,1); sf_setlabel(az,"z");
ax = sf_iaxa(Fwfl,2); sf_setlabel(ax,"x");
at = sf_iaxa(Fwfl,3); sf_setlabel(at,"t");
aa = sf_maxa(1,0,1);
sf_oaxa(Ftrc,ac,1);
sf_oaxa(Ftrc,at,2);
sf_oaxa(Ftrc,aa,3);
} else {
Ftrc = sf_input ("in" ); /* traces */
Fwfl = sf_output("out"); /* wavefield */
at = sf_iaxa(Ftrc,2); sf_setlabel(at,"t");
if(!sf_getint ("nz",&nz)) nz=1;
if(!sf_getfloat("oz",&oz)) oz=0.0;
if(!sf_getfloat("dz",&dz)) dz=1.0;
az = sf_maxa(nz,oz,dz);
sf_setlabel(az,"z");
if(!sf_getint ("nx",&nx)) nx=1;
if(!sf_getfloat("ox",&ox)) ox=0.0;
if(!sf_getfloat("dx",&dx)) dx=1.0;
ax = sf_maxa(nx,ox,dx);
sf_setlabel(ax,"x");
sf_oaxa(Fwfl,az,1);
sf_oaxa(Fwfl,ax,2);
sf_oaxa(Fwfl,at,3);
}
if(verb) {
sf_raxa(az);
sf_raxa(ax);
sf_raxa(at);
sf_raxa(ac);
}
/* allocate wavefield arrays */
wco = sf_floatalloc (sf_n(ac));
wfl = sf_floatalloc2(sf_n(az),sf_n(ax));
/* interpolation coefficients */
fdm = fdutil_init(verb,'n',az,ax,0,1);
cow = lint2d_make(sf_n(ac),coo,fdm);
/*------------------------------------------------------------*/
/*
* MAIN LOOP
*/
/*------------------------------------------------------------*/
if(verb) fprintf(stderr,"\n");
for (it=0; it<sf_n(at); it++) {
if(verb) fprintf(stderr,"\b\b\b\b\b%d",it);
if(adj) {
sf_floatread(wfl[0],sf_n(az)*sf_n(ax),Fwfl);
lint2d_extract(wfl,wco,cow);
sf_floatwrite(wco,sf_n(ac),Ftrc);
} else {
sf_floatread(wco,sf_n(ac),Ftrc);
for (ix=0; ix<sf_n(ax); ix++)
for(iz=0; iz<sf_n(az); iz++)
wfl[ix][iz]=0;
lint2d_inject(wfl,wco,cow);
sf_floatwrite(wfl[0],sf_n(az)*sf_n(ax),Fwfl);
}
} /* end time loop */
if(verb) fprintf(stderr,"\n");
/*------------------------------------------------------------*/
/* deallocate arrays */
free(*wfl); free(wfl);
free(wco);
free(coo);
/*------------------------------------------------------------*/
/* close files */
if (Ftrc!=NULL) sf_fileclose(Ftrc);
if (Fwfl!=NULL) sf_fileclose(Fwfl);
if (Fcoo!=NULL) sf_fileclose(Fcoo);
exit (0);
}
int main(int argc, char* argv[])
{
bool verb,fsrf,snap,ssou,dabc;
int jsnap,ntsnap,jdata;
/* I/O files */
sf_file Fwav=NULL; /* wavelet */
sf_file Fsou=NULL; /* sources */
sf_file Frec=NULL; /* receivers */
sf_file Fccc=NULL; /* velocity */
sf_file Fden=NULL; /* density */
sf_file Fdat=NULL; /* data */
sf_file Fwfl=NULL; /* wavefield */
/* cube axes */
sf_axis at,ax,ay,az;
sf_axis as,ar,ac;
int nt,nz,nx,ny,ns,nr,nc,nb;
int it,iz,ix,iy;
float dt,dz,dx,dy,idz,idx,idy;
/* FDM structure */
fdm3d fdm=NULL;
abcone3d abcp=NULL,abcs=NULL;
sponge1d spo=NULL;
/* I/O arrays */
float***ww=NULL; /* wavelet */
pt3d *ss=NULL; /* sources */
pt3d *rr=NULL; /* receivers */
float **dd=NULL; /* data */
/*------------------------------------------------------------*/
float ***tt=NULL;
float ***ro=NULL; /* density */
/* orthorombic stiffness - 9 coefficients */
/* c11 c12 c13
. c22 c23
. . c33
c44
c55
c66 */
float ***c11=NULL,***c12=NULL,***c13=NULL,***c14=NULL,***c15=NULL,***c16=NULL;
float ***c22=NULL,***c23=NULL,***c24=NULL,***c25=NULL,***c26=NULL;
float ***c33=NULL,***c34=NULL,***c35=NULL,***c36=NULL;
float ***c44=NULL,***c45=NULL,***c46=NULL;
float ***c55=NULL,***c56=NULL;
float ***c66=NULL;
float ***vp,***vs;
/*------------------------------------------------------------*/
/* displacement: um = U @ t-1; uo = U @ t; up = U @ t+1 */
float ***umz,***uoz,***upz,***uaz,***utz;
float ***umx,***uox,***upx,***uax,***utx;
float ***umy,***uoy,***upy,***uay,***uty;
/* stress/strain tensor */
float ***tzz,***txx,***tyy,***txy,***tyz,***tzx;
float szz, sxx, syy, sxy, syz, szx;
/*------------------------------------------------------------*/
/* linear interpolation weights/indices */
lint3d cs,cr;
/* */
int nbell;
/* wavefield cut params */
sf_axis acz=NULL,acx=NULL,acy=NULL;
int nqz,nqx,nqy;
float oqz,oqx,oqy;
float dqz,dqx,dqy;
float ***uc=NULL;
/*------------------------------------------------------------*/
/* init RSF */
sf_init(argc,argv);
/*------------------------------------------------------------*/
/* OMP parameters */
#ifdef _OPENMP
omp_init();
#endif
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* execution flags */
if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */
if(! sf_getbool("snap",&snap)) snap=false; /* wavefield snapshots flag */
if(! sf_getbool("free",&fsrf)) fsrf=false; /* free surface flag */
if(! sf_getbool("ssou",&ssou)) ssou=false; /* stress source */
if(! sf_getbool("dabc",&dabc)) dabc=false; /* absorbing BC */
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* I/O files */
Fwav = sf_input ("in" ); /* wavelet */
Fccc = sf_input ("ccc"); /* stiffness */
Fden = sf_input ("den"); /* density */
Fsou = sf_input ("sou"); /* sources */
Frec = sf_input ("rec"); /* receivers */
Fwfl = sf_output("wfl"); /* wavefield */
Fdat = sf_output("out"); /* data */
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* axes */
at = sf_iaxa(Fwav,3); sf_setlabel(at,"time"); sf_setunit(at,"s"); if(verb) sf_raxa(at); /* time */
az = sf_iaxa(Fccc,1); sf_setlabel(az,"space z"); sf_setunit(az,"km");if(verb) sf_raxa(az); /* depth */
ax = sf_iaxa(Fccc,2); sf_setlabel(ax,"space x"); sf_setunit(ax,"km");if(verb) sf_raxa(ax); /* space x */
ay = sf_iaxa(Fccc,3); sf_setlabel(ay,"space y"); sf_setunit(ay,"km");if(verb) sf_raxa(ay); /* space y */
as = sf_iaxa(Fsou,2); sf_setlabel(as,"sources"); sf_setunit(as,"km");if(verb) sf_raxa(as); /* sources */
ar = sf_iaxa(Frec,2); sf_setlabel(ar,"receivers");sf_setunit(ar,"km");if(verb) sf_raxa(ar); /* receivers */
nt = sf_n(at); dt = sf_d(at);
nz = sf_n(az); dz = sf_d(az);
nx = sf_n(ax); dx = sf_d(ax);
ny = sf_n(ay); dy = sf_d(ay);
ns = sf_n(as);
nr = sf_n(ar);
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* other execution parameters */
if(! sf_getint("nbell",&nbell)) nbell=1; /* bell size */
if(verb) sf_warning("nbell=%d",nbell);
if(! sf_getint("jdata",&jdata)) jdata=1;
if(snap) { /* save wavefield every *jsnap* time steps */
if(! sf_getint("jsnap",&jsnap)) jsnap=nt;
}
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* expand domain for FD operators and ABC */
if( !sf_getint("nb",&nb) || nb<NOP) nb=NOP;
fdm=fdutil3d_init(verb,fsrf,az,ax,ay,nb,1);
fdbell3d_init(nbell);
sf_setn(az,fdm->nzpad); sf_seto(az,fdm->ozpad); sf_setlabel(az,"expanded z");sf_setunit(az,"km");if(verb) sf_raxa(az);
sf_setn(ax,fdm->nxpad); sf_seto(ax,fdm->oxpad); sf_setlabel(ax,"expanded x");sf_setunit(ax,"km");if(verb) sf_raxa(ax);
sf_setn(ay,fdm->nypad); sf_seto(ay,fdm->oypad); sf_setlabel(ay,"expanded y");sf_setunit(ay,"km");if(verb) sf_raxa(ay);
/*------------------------------------------------------------*/
/* 3D vector components */
nc=3;
ac=sf_maxa(nc,0,1);
/*------------------------------------------------------------*/
/* setup output data header */
sf_oaxa(Fdat,ar,1);
sf_oaxa(Fdat,ac,2);
sf_setn(at,nt/jdata);
sf_setd(at,dt*jdata);
sf_oaxa(Fdat,at,3);
/* setup output wavefield header */
if(snap) {
if(!sf_getint ("nqz",&nqz)) nqz=sf_n(az);
if(!sf_getint ("nqx",&nqx)) nqx=sf_n(ax);
if(!sf_getint ("nqy",&nqy)) nqy=sf_n(ay);
if(!sf_getfloat("oqz",&oqz)) oqz=sf_o(az);
if(!sf_getfloat("oqx",&oqx)) oqx=sf_o(ax);
if(!sf_getfloat("oqy",&oqy)) oqy=sf_o(ay);
dqz=sf_d(az);
dqx=sf_d(ax);
dqy=sf_d(ay);
acz = sf_maxa(nqz,oqz,dqz); sf_setunit(acz,"km");sf_setlabel(acz,"snapshot z");sf_raxa(acz);
acx = sf_maxa(nqx,oqx,dqx); sf_setunit(acx,"km");sf_setlabel(acx,"snapshot x");sf_raxa(acx);
acy = sf_maxa(nqy,oqy,dqy); sf_setunit(acy,"km");sf_setlabel(acy,"snapshot y");sf_raxa(acy);
/* check if the imaging window fits in the wavefield domain */
uc=sf_floatalloc3(sf_n(acz),sf_n(acx),sf_n(acy));
ntsnap=0;
for(it=0; it<nt; it++) {
if(it%jsnap==0) ntsnap++;
}
sf_setn(at, ntsnap);
sf_setd(at,dt*jsnap);
sf_setlabel(at,"snapshot frames");
if(verb) sf_raxa(at);
sf_oaxa(Fwfl,acz,1);
sf_oaxa(Fwfl,acx,2);
sf_oaxa(Fwfl,acy,3);
sf_oaxa(Fwfl,ac, 4);
sf_oaxa(Fwfl,at, 5);
}
/*------------------------------------------------------------*/
/* source array */
ww=sf_floatalloc3(ns,nc,nt);
sf_floatread(ww[0][0],nt*nc*ns,Fwav);
/* data array */
dd=sf_floatalloc2(nr,nc);
/*------------------------------------------------------------*/
/* setup source/receiver coordinates */
ss = (pt3d*) sf_alloc(ns,sizeof(*ss));
rr = (pt3d*) sf_alloc(nr,sizeof(*rr));
pt3dread1(Fsou,ss,ns,3); /* read (x,y,z) coordinates */
pt3dread1(Frec,rr,nr,3); /* read (x,y,z) coordinates */
cs = lint3d_make(ns,ss,fdm);
cr = lint3d_make(nr,rr,fdm);
/*------------------------------------------------------------*/
/* setup FD coefficients */
idz = 1/dz;
idx = 1/dx;
idy = 1/dy;
/*------------------------------------------------------------*/
tt = sf_floatalloc3(nz,nx,ny);
ro =sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c11=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c12=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c13=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c14=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c15=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c16=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c22=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c23=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c24=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c25=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c26=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c33=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c34=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c35=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c36=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c44=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c45=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c46=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c55=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c56=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
c66=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
/* input density */
sf_floatread(tt[0][0],nz*nx*ny,Fden); expand3d(tt,ro ,fdm);
/* input stiffness */
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c11,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c12,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c13,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c14,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c15,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c16,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c22,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c23,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c24,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c25,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c26,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c33,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c34,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c35,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c36,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c44,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c45,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c46,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c55,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c56,fdm);
sf_floatread(tt[0][0],nz*nx*ny,Fccc ); expand3d(tt,c66,fdm);
free(**tt); free(*tt); free(tt);
/*------------------------------------------------------------*/
if(dabc) {
/* one-way abc setup */
vp = sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
vs = sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
vp[iy][ix][iz] = sqrt( c11[iy][ix][iz]/ro[iy][ix][iz] );
vs[iy][ix][iz] = sqrt( c13[iy][ix][iz]/ro[iy][ix][iz] );
}
}
}
abcp = abcone3d_make(NOP,dt,vp,fsrf,fdm);
abcs = abcone3d_make(NOP,dt,vs,fsrf,fdm);
free(**vp); free(*vp); free(vp);
free(**vs); free(*vs); free(vs);
/* sponge abc setup */
spo = sponge_make(fdm->nb);
}
/*------------------------------------------------------------*/
/* precompute 1/ro * dt^2 */ for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
ro[iy][ix][iz] = dt*dt/ro[iy][ix][iz];
}
}
}
/*------------------------------------------------------------*/
/* allocate wavefield arrays */
umz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uoz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
upz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uaz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
umx=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uox=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
upx=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uax=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
umy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uoy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
upy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
uay=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
tzz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
tyy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
txx=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
txy=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
tyz=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
tzx=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad);
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
umz[iy][ix][iz]=0; umx[iy][ix][iz]=0; umy[iy][ix][iz]=0;
uoz[iy][ix][iz]=0; uox[iy][ix][iz]=0; uoy[iy][ix][iz]=0;
upz[iy][ix][iz]=0; upx[iy][ix][iz]=0; upy[iy][ix][iz]=0;
uaz[iy][ix][iz]=0; uax[iy][ix][iz]=0; uay[iy][ix][iz]=0;
}
}
}
/*------------------------------------------------------------*/
/*
* MAIN LOOP
*/
/*------------------------------------------------------------*/
if(verb) fprintf(stderr,"\n");
for (it=0; it<nt; it++) {
if(verb) fprintf(stderr,"\b\b\b\b\b%d",it);
/*------------------------------------------------------------*/
/* from displacement to strain */
/*------------------------------------------------------------*/
/*
* exx = Dx(ux)
* eyy = Dy(uy)
* ezz = Dz(uz)
* exy = Dy(ux) + Dx(uy)
* eyz = Dz(uy) + Dy(uz)
* ezx = Dx(uz) + Dz(ux)
*/
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz) \
shared(fdm,txx,tyy,tzz,txy,tyz,tzx,uox,uoy,uoz,idx,idy,idz)
#endif
for (iy=NOP; iy<fdm->nypad-NOP; iy++) {
for (ix=NOP; ix<fdm->nxpad-NOP; ix++) {
for(iz=NOP; iz<fdm->nzpad-NOP; iz++) {
txx[iy][ix][iz] = Dx(uox,ix,iy,iz,idx);
tyy[iy][ix][iz] = Dy(uoy,ix,iy,iz,idy);
tzz[iy][ix][iz] = Dz(uoz,ix,iy,iz,idz);
txy[iy][ix][iz] = Dy(uox,ix,iy,iz,idy) + Dx(uoy,ix,iy,iz,idx);
tyz[iy][ix][iz] = Dz(uoy,ix,iy,iz,idz) + Dy(uoz,ix,iy,iz,idy);
tzx[iy][ix][iz] = Dx(uoz,ix,iy,iz,idx) + Dz(uox,ix,iy,iz,idz);
}
}
}
/*------------------------------------------------------------*/
/* from strain to stress */
/*------------------------------------------------------------*/
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz,sxx,syy,szz,sxy,syz,szx) \
shared(fdm,txx,tyy,tzz,txy,tyz,tzx,c11,c12,c13,c14,c15,c16,c22,c23,c24,c25,c26,c33,c34,c35,c36,c44,c45,c46,c55,c56,c66)
#endif
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
sxx = c11[iy][ix][iz] * txx[iy][ix][iz]
+ c12[iy][ix][iz] * tyy[iy][ix][iz]
+ c13[iy][ix][iz] * tzz[iy][ix][iz]
+ c14[iy][ix][iz] * tyz[iy][ix][iz]
+ c15[iy][ix][iz] * tzx[iy][ix][iz]
+ c16[iy][ix][iz] * txy[iy][ix][iz];
syy = c12[iy][ix][iz] * txx[iy][ix][iz]
+ c22[iy][ix][iz] * tyy[iy][ix][iz]
+ c23[iy][ix][iz] * tzz[iy][ix][iz]
+ c24[iy][ix][iz] * tyz[iy][ix][iz]
+ c25[iy][ix][iz] * tzx[iy][ix][iz]
+ c26[iy][ix][iz] * txy[iy][ix][iz];
szz = c13[iy][ix][iz] * txx[iy][ix][iz]
+ c23[iy][ix][iz] * tyy[iy][ix][iz]
+ c33[iy][ix][iz] * tzz[iy][ix][iz]
+ c34[iy][ix][iz] * tyz[iy][ix][iz]
+ c35[iy][ix][iz] * tzx[iy][ix][iz]
+ c36[iy][ix][iz] * txy[iy][ix][iz];
syz = c14[iy][ix][iz] * txx[iy][ix][iz]
+ c24[iy][ix][iz] * tyy[iy][ix][iz]
+ c34[iy][ix][iz] * tzz[iy][ix][iz]
+ c44[iy][ix][iz] * tyz[iy][ix][iz]
+ c45[iy][ix][iz] * tzx[iy][ix][iz]
+ c46[iy][ix][iz] * txy[iy][ix][iz];
szx = c15[iy][ix][iz] * txx[iy][ix][iz]
+ c25[iy][ix][iz] * tyy[iy][ix][iz]
+ c35[iy][ix][iz] * tzz[iy][ix][iz]
+ c45[iy][ix][iz] * tyz[iy][ix][iz]
+ c55[iy][ix][iz] * tzx[iy][ix][iz]
+ c56[iy][ix][iz] * txy[iy][ix][iz];
sxy = c16[iy][ix][iz] * txx[iy][ix][iz]
+ c26[iy][ix][iz] * tyy[iy][ix][iz]
+ c36[iy][ix][iz] * tzz[iy][ix][iz]
+ c46[iy][ix][iz] * tyz[iy][ix][iz]
+ c56[iy][ix][iz] * tzx[iy][ix][iz]
+ c66[iy][ix][iz] * txy[iy][ix][iz];
txx[iy][ix][iz] = sxx;
tyy[iy][ix][iz] = syy;
tzz[iy][ix][iz] = szz;
txy[iy][ix][iz] = sxy;
tyz[iy][ix][iz] = syz;
tzx[iy][ix][iz] = szx;
}
}
}
/*------------------------------------------------------------*/
/* free surface */
/*------------------------------------------------------------*/
if(fsrf) {
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz) \
shared(fdm,txx,tyy,tzz,txy,tyz,tzx)
#endif
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nb; iz++) {
txx[iy][ix][iz]=0;
tyy[iy][ix][iz]=0;
tzz[iy][ix][iz]=0;
txy[iy][ix][iz]=0;
tyz[iy][ix][iz]=0;
tzx[iy][ix][iz]=0;
}
}
}
}
/*------------------------------------------------------------*/
/* inject stress source */
/*------------------------------------------------------------*/
if(ssou) {
lint3d_bell(txx,ww[it][0],cs);
lint3d_bell(tyy,ww[it][1],cs);
lint3d_bell(tzz,ww[it][2],cs);
}
/*------------------------------------------------------------*/
/* from stress to acceleration */
/*------------------------------------------------------------*/
/*
* ax = Dx(txx) + Dy(txy) + Dz(txz)
* ay = Dx(txy) + Dy(tyy) + Dz(tyz)
* az = Dx(txz) + Dy(tyz) + Dz(tzz)
*/
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz) \
shared(fdm,txx,tyy,tzz,txy,tyz,tzx,uax,uay,uaz,idx,idy,idz)
#endif
for (iy=NOP; iy<fdm->nypad-NOP; iy++) {
for (ix=NOP; ix<fdm->nxpad-NOP; ix++) {
for(iz=NOP; iz<fdm->nzpad-NOP; iz++) {
uax[iy][ix][iz] = Dx( txx,ix,iy,iz,idx) + Dy( txy,ix,iy,iz,idy) + Dz( tzx,ix,iy,iz,idz) ;
uay[iy][ix][iz] = Dx( txy,ix,iy,iz,idx) + Dy( tyy,ix,iy,iz,idy) + Dz( tyz,ix,iy,iz,idz) ;
uaz[iy][ix][iz] = Dx( tzx,ix,iy,iz,idx) + Dy( tyz,ix,iy,iz,idy) + Dz( tzz,ix,iy,iz,idz) ;
}
}
}
/*------------------------------------------------------------*/
/* inject acceleration source */
/*------------------------------------------------------------*/
if(!ssou) {
lint3d_bell(uaz,ww[it][0],cs);
lint3d_bell(uax,ww[it][1],cs);
lint3d_bell(uay,ww[it][2],cs);
}
/*------------------------------------------------------------*/
/* step forward in time */
/*------------------------------------------------------------*/
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,fdm->ompchunk) \
private(ix,iy,iz) \
shared(fdm,uox,uoy,uoz,umx,umy,umz,upx,upy,upz,uax,uay,uaz,ro)
#endif
for (iy=0; iy<fdm->nypad; iy++) {
for (ix=0; ix<fdm->nxpad; ix++) {
for(iz=0; iz<fdm->nzpad; iz++) {
upx[iy][ix][iz] = 2*uox[iy][ix][iz]
- umx[iy][ix][iz]
+ uax[iy][ix][iz] * ro[iy][ix][iz];
upy[iy][ix][iz] = 2*uoy[iy][ix][iz]
- umy[iy][ix][iz]
+ uay[iy][ix][iz] * ro[iy][ix][iz];
upz[iy][ix][iz] = 2*uoz[iy][ix][iz]
- umz[iy][ix][iz]
+ uaz[iy][ix][iz] * ro[iy][ix][iz];
}
}
}
/* circulate wavefield arrays */
utz=umz; uty=umy; utx=umx;
umz=uoz; umy=uoy; umx=uox;
uoz=upz; uoy=upy; uox=upx;
upz=utz; upy=uty; upx=utx;
if(dabc) {
/* one-way ABC */
abcone3d_apply(uoz,umz,NOP,abcp,fdm);
abcone3d_apply(uox,umx,NOP,abcp,fdm);
abcone3d_apply(uoy,umy,NOP,abcp,fdm);
abcone3d_apply(uoz,umz,NOP,abcs,fdm);
abcone3d_apply(uox,umx,NOP,abcs,fdm);
abcone3d_apply(uoy,umy,NOP,abcs,fdm);
/* sponge ABC */
sponge3d_apply(umz,spo,fdm);
sponge3d_apply(uoz,spo,fdm);
sponge3d_apply(upz,spo,fdm);
sponge3d_apply(umx,spo,fdm);
sponge3d_apply(uox,spo,fdm);
sponge3d_apply(upx,spo,fdm);
sponge3d_apply(umy,spo,fdm);
sponge3d_apply(uoy,spo,fdm);
sponge3d_apply(upy,spo,fdm);
}
/*------------------------------------------------------------*/
/* cut wavefield and save */
/*------------------------------------------------------------*/
lint3d_extract(uoz,dd[0],cr);
lint3d_extract(uox,dd[1],cr);
lint3d_extract(uoy,dd[2],cr);
if(snap && it%jsnap==0) {
cut3d(uoz,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
cut3d(uox,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
cut3d(uoy,uc,fdm,acz,acx,acy);
sf_floatwrite(uc[0][0],sf_n(acx)*sf_n(acy)*sf_n(acz),Fwfl);
}
if(it%jdata==0) sf_floatwrite(dd[0],nr*nc,Fdat);
}
if(verb) fprintf(stderr,"\n");
/*------------------------------------------------------------*/
/* deallocate arrays */
free(**ww); free(*ww); free(ww);
free(ss);
free(rr);
free(*dd); free(dd);
free(**ro); free(*ro); free(ro);
free(**c11); free(*c11); free(c11);
free(**c12); free(*c12); free(c12);
free(**c13); free(*c13); free(c13);
free(**c14); free(*c14); free(c14);
free(**c15); free(*c15); free(c15);
free(**c16); free(*c16); free(c16);
free(**c22); free(*c22); free(c22);
free(**c23); free(*c23); free(c23);
free(**c24); free(*c24); free(c24);
free(**c25); free(*c25); free(c25);
free(**c26); free(*c26); free(c26);
free(**c33); free(*c33); free(c33);
free(**c34); free(*c34); free(c34);
free(**c35); free(*c35); free(c35);
free(**c36); free(*c36); free(c36);
free(**c44); free(*c44); free(c44);
free(**c45); free(*c45); free(c45);
free(**c46); free(*c46); free(c46);
free(**c55); free(*c55); free(c55);
free(**c56); free(*c56); free(c56);
free(**c66); free(*c66); free(c66);
free(**umz); free(*umz); free(umz);
free(**uoz); free(*uoz); free(uoz);
free(**upz); free(*upz); free(upz);
free(**uaz); free(*uaz); free(uaz);
free(**umx); free(*umx); free(umx);
free(**uox); free(*uox); free(uox);
free(**upx); free(*upx); free(upx);
free(**uax); free(*uax); free(uax);
free(**umy); free(*umy); free(umy);
free(**uoy); free(*uoy); free(uoy);
free(**upy); free(*upy); free(upy);
free(**uay); free(*uay); free(uay);
free(**tzz); free(*tzz); free(tzz);
free(**txx); free(*txx); free(txx);
free(**tyy); free(*tyy); free(tyy);
free(**txy); free(*txy); free(txy);
free(**tyz); free(*tyz); free(tyz);
free(**tzx); free(*tzx); free(tzx);
free(**uc); free(*uc); free(uc);
exit (0);
}
int main (int argc, char *argv[])
{
const char *mode; /* mode of operation */
bool verb; /* verbosity */
bool inv; /* forward or adjoint */
bool twoway; /* two-way traveltime */
float eps; /* dip filter constant */
int nrmax; /* number of reference velocities */
float dtmax; /* time error */
int pmx,pmy,phx; /* padding in the k domain */
int tmx,tmy,thx; /* boundary taper size */
sf_axis amx,amy,amz;
sf_axis ahx;
sf_axis alx,aly;
sf_axis aw;
int nz, n, nw;
float dw, w0;
/* I/O files */
sf_file Fs=NULL; /* slowness file S(nlx,nly, nz ) */
sf_file Fi=NULL; /* image file R(nmx,nmy,nhx,nz ) */
sf_file Fd=NULL; /* data file D(nmx,nmy,nhx, nw) */
sf_file Fw=NULL;
/* I/O slices */
sf_fslice slow=NULL;
sf_fslice imag=NULL;
sf_fslice data=NULL;
sf_fslice wfld=NULL;
int ompchunk=1;
int ompnth=1;
#ifdef _OPENMP
int ompath=1;
#endif
cub3d cub; /* wavefield hypercube */
tap3d tap; /* tapering */
cam3d cam; /* CAM operator */
slo3d slo; /* slowness */
camoperator3d weop;
float dsmax;
/*------------------------------------------------------------*/
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
/* default mode is migration/modeling */
if (NULL == (mode = sf_getstring("mode"))) mode = "m";
if (!sf_getbool( "verb", &verb )) verb = false; /* verbosity flag */
if (!sf_getfloat("eps", &eps )) eps = 0.01; /* stability parameter */
if (!sf_getbool( "inv", &inv )) inv = false; /* y=modeling; n=migration */
if (!sf_getbool("twoway",&twoway))twoway= false; /* two-way traveltime */
if (!sf_getint( "nrmax",&nrmax)) nrmax = 1; /* maximum number of refs */
if (!sf_getfloat("dtmax",&dtmax)) dtmax = 0.004; /* time error */
if (!sf_getint( "pmx", &pmx )) pmx = 0; /* padding mx*/
if (!sf_getint( "pmy", &pmy )) pmy = 0; /* padding my*/
if (!sf_getint( "phx", &phx )) phx = 0; /* padding hx*/
if (!sf_getint( "tmx", &tmx )) tmx = 0; /* taper mx */
if (!sf_getint( "tmy", &tmy )) tmy = 0; /* taper my */
if (!sf_getint( "thx", &thx )) thx = 0; /* taper hx */
/* slowness parameters */
Fs = sf_input ("slo");
alx = sf_iaxa(Fs,1); sf_setlabel(alx,"lx");
aly = sf_iaxa(Fs,2); sf_setlabel(aly,"ly");
amz = sf_iaxa(Fs,3); sf_setlabel(amz,"z" );
n = sf_n(alx)*sf_n(aly);
nz = sf_n(amz);
slow = sf_fslice_init(n,nz,sizeof(float));
sf_fslice_load(Fs,slow,SF_FLOAT);
switch(mode[0]) {
case 'w': /* save wavefield */
Fd = sf_input ( "in");
Fw = sf_output("out"); sf_settype(Fw,SF_COMPLEX);
if (SF_COMPLEX !=sf_gettype(Fd)) sf_error("Need complex data");
amx = sf_iaxa(Fd,1); sf_setlabel(amx,"mx"); sf_oaxa(Fw,amx,1);
amy = sf_iaxa(Fd,2); sf_setlabel(amy,"my"); sf_oaxa(Fw,amy,2);
ahx = sf_iaxa(Fd,3); sf_setlabel(ahx,"hx"); sf_oaxa(Fw,ahx,3);
; sf_oaxa(Fw,amz,4);
aw = sf_iaxa(Fd,4); sf_setlabel(aw ,"w" ); sf_oaxa(Fw,aw ,5);
n = sf_n(amx)*sf_n(amy)*sf_n(ahx);
nw = sf_n(aw);
data = sf_fslice_init(n, nw,sizeof(sf_complex));
wfld = sf_fslice_init(n,nz*nw,sizeof(sf_complex));
sf_fslice_load(Fd,data,SF_COMPLEX);
break;
case 'd':
if (inv) { /* upward continuation */
Fw = sf_input ( "in");
Fd = sf_output("out"); sf_settype(Fd,SF_COMPLEX);
if (SF_COMPLEX !=sf_gettype(Fw)) sf_error("Need complex data");
amx = sf_iaxa(Fw,1); sf_setlabel(amx,"mx"); sf_oaxa(Fd,amx,1);
amy = sf_iaxa(Fw,2); sf_setlabel(amy,"my"); sf_oaxa(Fd,amy,2);
ahx = sf_iaxa(Fw,3); sf_setlabel(ahx,"hx"); sf_oaxa(Fd,ahx,3);
aw = sf_iaxa(Fw,4); sf_setlabel(aw , "w"); sf_oaxa(Fd,aw ,4);
n = sf_n(amx)*sf_n(amy)*sf_n(ahx);
nw = sf_n(aw);
data = sf_fslice_init(n,nw,sizeof(sf_complex));
wfld = sf_fslice_init(n,nw,sizeof(sf_complex));
sf_fslice_load(Fw,wfld,SF_COMPLEX);
} else { /* downward continuation */
Fd = sf_input ( "in");
Fw = sf_output("out"); sf_settype(Fw,SF_COMPLEX);
if (SF_COMPLEX !=sf_gettype(Fd)) sf_error("Need complex data");
amx = sf_iaxa(Fd,1); sf_setlabel(amx,"mx"); sf_oaxa(Fw,amx,1);
amy = sf_iaxa(Fd,2); sf_setlabel(amy,"my"); sf_oaxa(Fw,amy,2);
ahx = sf_iaxa(Fd,3); sf_setlabel(ahx,"hx"); sf_oaxa(Fw,ahx,3);
aw = sf_iaxa(Fd,4); sf_setlabel(aw , "w"); sf_oaxa(Fw,aw ,4);
n = sf_n(amx)*sf_n(amy)*sf_n(ahx);
nw = sf_n(aw);
data = sf_fslice_init(n,nw,sizeof(sf_complex));
wfld = sf_fslice_init(n,nw,sizeof(sf_complex));
sf_fslice_load(Fd,data,SF_COMPLEX);
}
break;
case 'm':
default:
if (inv) { /* modeling */
Fi = sf_input ( "in");
Fd = sf_output("out"); sf_settype(Fd,SF_COMPLEX);
if (SF_FLOAT !=sf_gettype(Fi)) sf_error("Need float image");
if (!sf_getint ("nw",&nw)) sf_error ("Need nw=");
if (!sf_getfloat("dw",&dw)) sf_error ("Need dw=");
if (!sf_getfloat("ow",&w0)) w0=0.;
aw = sf_maxa(nw,w0,dw);
sf_setlabel(aw, "w");
sf_setunit (aw,"1/s");
amx = sf_iaxa(Fi,1); sf_setlabel(amx,"mx"); sf_oaxa(Fd,amx,1);
amy = sf_iaxa(Fi,2); sf_setlabel(amy,"my"); sf_oaxa(Fd,amy,2);
ahx = sf_iaxa(Fi,3); sf_setlabel(ahx,"hx"); sf_oaxa(Fd,ahx,3);
amz = sf_iaxa(Fi,4); sf_setlabel(amz, "z"); sf_oaxa(Fd,aw ,4);
n = sf_n(amx)*sf_n(amy)*sf_n(ahx);
data = sf_fslice_init(n,nw,sizeof(sf_complex));
imag = sf_fslice_init(n,nz,sizeof(float));
sf_fslice_load(Fi,imag,SF_FLOAT);
} else { /* migration */
Fd = sf_input ( "in");
Fi = sf_output("out"); sf_settype(Fi,SF_FLOAT);
if (SF_COMPLEX !=sf_gettype(Fd)) sf_error("Need complex data");
amx = sf_iaxa(Fd,1); sf_setlabel(amx,"mx"); sf_oaxa(Fi,amx,1);
amy = sf_iaxa(Fd,2); sf_setlabel(amy,"my"); sf_oaxa(Fi,amy,2);
ahx = sf_iaxa(Fd,3); sf_setlabel(ahx,"hx"); sf_oaxa(Fi,ahx,3);
aw = sf_iaxa(Fd,4); sf_setlabel(aw , "w"); sf_oaxa(Fi,amz,4);
n = sf_n(amx)*sf_n(amy)*sf_n(ahx);
nw = sf_n(aw);
data = sf_fslice_init(n,nw,sizeof(sf_complex));
imag = sf_fslice_init(n,nz,sizeof(float));
sf_fslice_load(Fd,data,SF_COMPLEX);
}
break;
}
/*------------------------------------------------------------*/
cub = camig3_cube(verb,
amx,amy,amz,ahx,
alx,aly,
aw,
eps,
ompnth,
ompchunk);
dsmax = dtmax/cub->amz.d;
/*------------------------------------------------------------*/
/* init structures */
tap = taper_init(cub->amx.n,
cub->amy.n,
cub->ahx.n,
SF_MIN(tmx,cub->amx.n-1),
SF_MIN(tmy,cub->amy.n-1),
SF_MIN(thx,cub->ahx.n-1),
true,false,false);
cam = cam3_init(cub,pmx,pmy,phx,tmx,tmy,thx,dsmax);
slo = slow3_init(cub,slow,nrmax,dsmax,twoway);
/*------------------------------------------------------------*/
weop = camig3_init(cub);
switch(mode[0]) {
case 'w':
cawfl3(weop,cub,cam,tap,slo,inv,data,wfld);
break;
case 'd':
cadtm3(weop,cub,cam,tap,slo,inv,data,wfld);
break;
case 'm':
default:
camig3(weop,cub,cam,tap,slo,inv,data,imag);
break;
}
camig3_close(weop);
/*------------------------------------------------------------*/
/* close structures */
slow3_close(slo);
cam3_close(cam);
taper2d_close(tap);
/*------------------------------------------------------------*/
/* slice management (temp files) */
switch(mode[0]) {
case 'w':
sf_fslice_dump(Fw,wfld,SF_COMPLEX);
sf_fslice_close(data);
sf_fslice_close(wfld);
break;
case 'd':
if(inv) sf_fslice_dump(Fd,data,SF_COMPLEX);
else sf_fslice_dump(Fw,wfld,SF_COMPLEX);
sf_fslice_close(data);
sf_fslice_close(wfld);
break;
case 'm':
if(inv) sf_fslice_dump(Fd,data,SF_COMPLEX);
else sf_fslice_dump(Fi,imag,SF_FLOAT);
sf_fslice_close(data);
sf_fslice_close(imag);
default:
break;
}
sf_fslice_close(slow);
/*------------------------------------------------------------*/
exit (0);
}
/*------------------------------------------------------------*/
int main(int argc, char* argv[])
{
bool verb; /* verbosity flag */
bool pos; /* direction of spraying */
bool adj; /* adjoint operator flag */
bool wflcausal, oprcausal; /* causal wfl?, opr? */
sf_file Fopr, Fwfl, Fimg, Fcip; /* I/O files */
float ****opr=NULL,****wfl=NULL,*****img=NULL;
int itO,itW;
sf_axis az,ax,ay,at,ac,aa; /* wfld axes */
int nz,nx,ny,nt,nc;
int iz,ix,iy,it,ic;
sf_axis ahx, ahy, ahz, aht; /* EIC axes */
int nhx, nhy, nhz, nht;
int ihx, ihy, ihz, iht;
float dhx, dhy, dhz, dht;
pt3d *cc=NULL;
bool *ccin=NULL;
float cxmin,czmin,cymin;
float cxmax,czmax,cymax;
int icx, icz, icy;
int mcx, mcz, mcy, mct;
int pcx, pcz, pcy, pct;
int **mcxall, **pcxall;
int **mcyall, **pcyall;
int **mczall, **pczall;
int *mctall, *pctall;
int lht,fht; /* last buffer index */
float scale; /* time summation scaling */
int nslice; /* wavefield slice size */
bool gaus; /* gaussian taper */
float gsx,gsy,gsz,gst; /* std dev */
/*------------------------------------------------------------*/
sf_init(argc,argv);
#ifdef _OPENMP
omp_init();
#endif
if(! sf_getbool( "verb",&verb )) verb=false; /* verbosity flag */
if(! sf_getbool( "positive",&pos )) pos=true; /* if positive sprays opr to positive shits, else, sprays to negative shifts */
if(! sf_getbool( "adj",&adj )) adj=false; /* adjoint flag */
if(! sf_getbool("wflcausal",&wflcausal)) wflcausal=false; /* causal wfl? */
if(! sf_getbool("oprcausal",&oprcausal)) oprcausal=false; /* causal opr? */
/*------------------------------------------------------------*/
Fopr = sf_input ("opr" ); /* operator */
az=sf_iaxa(Fopr,1); if(verb) sf_raxa(az); nz = sf_n(az);
ax=sf_iaxa(Fopr,2); if(verb) sf_raxa(ax); nx = sf_n(ax);
ay=sf_iaxa(Fopr,3); if(verb) sf_raxa(ay); ny = sf_n(ay);
at=sf_iaxa(Fopr,4); if(verb) sf_raxa(at); nt = sf_n(at);
scale = 1./nt; /* time summation scaling */
nslice = nz*nx*ny*sizeof(float); /* wavefield slice */
Fcip = sf_input ("cip" ); /* CIP coordinates */
ac = sf_iaxa(Fcip,2);
sf_setlabel(ac,"c"); sf_setunit(ac,""); if(verb) sf_raxa(ac); nc = sf_n(ac);
/*------------------------------------------------------------*/
/* setup output */
if(adj) {
Fimg = sf_input ("in"); /* read img */
ahz=sf_iaxa(Fimg,1); nhz=(sf_n(ahz)-1)/2; if(verb) sf_raxa(ahz);
ahx=sf_iaxa(Fimg,2); nhx=(sf_n(ahx)-1)/2; if(verb) sf_raxa(ahx);
ahy=sf_iaxa(Fimg,3); nhy=(sf_n(ahy)-1)/2; if(verb) sf_raxa(ahy);
aht=sf_iaxa(Fimg,4); nht=(sf_n(aht)-1)/2; if(verb) sf_raxa(aht);
aa=sf_maxa(1,0,1); sf_setlabel(aa,""); sf_setunit(aa,"");
/* set output axes */
Fwfl = sf_output("out"); /* write wfl */
sf_oaxa(Fwfl,az,1);
sf_oaxa(Fwfl,ax,2);
sf_oaxa(Fwfl,ay,3);
sf_oaxa(Fwfl,at,4);
sf_oaxa(Fwfl,aa,5);
} else {
Fwfl = sf_input ( "in"); /* read wfl */
if(! sf_getint("nhz",&nhz)) nhz=0; /* z lags */
dhz=2*sf_d(az);
ahz=sf_maxa(2*nhz+1,-nhz*dhz,dhz); sf_setlabel(ahz,"hz"); sf_setunit(ahz,"");
if(verb) sf_raxa(ahz);
if(! sf_getint("nhx",&nhx)) nhx=0; /* x lags */
dhx=2*sf_d(ax);
ahx=sf_maxa(2*nhx+1,-nhx*dhx,dhx); sf_setlabel(ahx,"hx"); sf_setunit(ahx,"");
if(verb) sf_raxa(ahx);
if(! sf_getint("nhy",&nhy)) nhy=0; /* y lags */
dhy=2*sf_d(ay);
ahy=sf_maxa(2*nhy+1,-nhy*dhy,dhy); sf_setlabel(ahy,"hy"); sf_setunit(ahy,"");
if(verb) sf_raxa(ahy);
if(! sf_getint("nht",&nht)) nht=0; /* t lags */
dht=2*sf_d(at);
aht=sf_maxa(2*nht+1,-nht*dht,dht); sf_setlabel(aht,"ht"); sf_setunit(aht,"");
if(verb) sf_raxa(aht);
Fimg = sf_output("out"); /* write img */
sf_oaxa(Fimg,ahz,1);
sf_oaxa(Fimg,ahx,2);
sf_oaxa(Fimg,ahy,3);
sf_oaxa(Fimg,aht,4);
sf_oaxa(Fimg, ac,5);
}
/*------------------------------------------------------------*/
if(! sf_getbool("gaus",&gaus)) gaus=false; /* Gaussian taper */
if(gaus) {
if(! sf_getfloat("gsx",&gsx)) gsx=0.25*sf_n(ahx)*sf_d(ahx); gsx=(nhx==0)?1:1./(2*gsx*gsx);
if(! sf_getfloat("gsy",&gsy)) gsy=0.25*sf_n(ahy)*sf_d(ahy); gsy=(nhy==0)?1:1./(2*gsy*gsy);
if(! sf_getfloat("gsz",&gsz)) gsz=0.25*sf_n(ahz)*sf_d(ahz); gsz=(nhz==0)?1:1./(2*gsz*gsz);
if(! sf_getfloat("gst",&gst)) gst=0.25*sf_n(aht)*sf_d(aht); gst=(nht==0)?1:1./(2*gst*gst);
}
/*------------------------------------------------------------*/
/* allocate arrays */
opr=sf_floatalloc4(nz,nx,ny,sf_n(aht));
wfl=sf_floatalloc4(nz,nx,ny,sf_n(aht));
img=sf_floatalloc5(sf_n(ahz),sf_n(ahx),sf_n(ahy),sf_n(aht),sf_n(ac));
/*------------------------------------------------------------*/
/* CIP coordinates */
cc= (pt3d*) sf_alloc(nc,sizeof(*cc));
pt3dread1(Fcip,cc,nc,3);
mcxall=sf_intalloc2(sf_n(ahx),sf_n(ac));
pcxall=sf_intalloc2(sf_n(ahx),sf_n(ac));
mcyall=sf_intalloc2(sf_n(ahy),sf_n(ac));
pcyall=sf_intalloc2(sf_n(ahy),sf_n(ac));
mczall=sf_intalloc2(sf_n(ahz),sf_n(ac));
pczall=sf_intalloc2(sf_n(ahz),sf_n(ac));
ccin=sf_boolalloc(sf_n(ac));
cxmin = sf_o(ax) + nhx *sf_d(ax);
cxmax = sf_o(ax) + (sf_n(ax)-1-nhx)*sf_d(ax);
cymin = sf_o(ay) + nhy *sf_d(ay);
cymax = sf_o(ay) + (sf_n(ay)-1-nhy)*sf_d(ay);
czmin = sf_o(az) + nhz *sf_d(az);
czmax = sf_o(az) + (sf_n(az)-1-nhz)*sf_d(az);
for(ic=0;ic<nc;ic++) {
ccin[ic]=(cc[ic].x>=cxmin && cc[ic].x<=cxmax &&
cc[ic].y>=cymin && cc[ic].y<=cymax &&
cc[ic].z>=czmin && cc[ic].z<=czmax)?true:false;
if(ccin[ic]) {
icx = 0.5+(cc[ic].x-sf_o(ax))/sf_d(ax);
for(ihx=-nhx; ihx<nhx+1; ihx++) {
mcxall[ic][nhx+ihx] = icx-ihx;
pcxall[ic][nhx+ihx] = icx+ihx;
}
icy = 0.5+(cc[ic].y-sf_o(ay))/sf_d(ay);
for(ihy=-nhy; ihy<nhy+1; ihy++) {
mcyall[ic][nhy+ihy] = icy-ihy;
pcyall[ic][nhy+ihy] = icy+ihy;
}
icz = 0.5+(cc[ic].z-sf_o(az))/sf_d(az);
for(ihz=-nhz; ihz<nhz+1; ihz++) {
mczall[ic][nhz+ihz] = icz-ihz;
pczall[ic][nhz+ihz] = icz+ihz;
}
}
}
mctall=sf_intalloc(sf_n(aht));
pctall=sf_intalloc(sf_n(aht));
for (iht=0; iht<sf_n(aht); iht++) {
mctall[iht]= iht;
pctall[iht]=sf_n(aht)-1-iht;
}
if(adj) { /* ADJIONT OPERATOR */
for(iht=0;iht<sf_n(aht);iht++)
CICLOOP( wfl[iht][iy][ix][iz]=0; ); /* zero wfl */
for(it=0;it<nt;it++) sf_floatwrite(wfl[0][0][0],nz*nx*ny,Fwfl); /* reserve wfl */
sf_seek(Fwfl,0,SEEK_SET); /* seek back */
sf_floatread(img[0][0][0][0],sf_n(ac)*sf_n(ahy)*sf_n(ahx)*sf_n(ahz)*sf_n(aht),Fimg); /* read img */
; applyScaling (img,ac,aht,ahx,ahy,ahz,scale); /* scaling */
if(gaus) applyGaussian(img,ac,aht,ahx,ahy,ahz,gst,gsx,gsy,gsz); /* Gaussian */
lht=0; itO=-999999; itW=-999999;
for(it=-nht;it<nt+nht;it++) { if(verb) fprintf(stderr,"\b\b\b\b\b\b%04d",it);
fht=(lht+1) % sf_n(aht);
if(it<nt-nht) {
itO = it + nht;
if( !oprcausal ) sf_seek(Fopr,(off_t)(nt-1-itO)*nslice,SEEK_SET);
else sf_seek(Fopr,(off_t) itO *nslice,SEEK_SET);
sf_floatread(opr[ lht ][0][0],nz*nx*ny,Fopr);
}
for(iht=0;iht<sf_n(aht);iht++) {
mctall[iht] = (mctall[iht]+1) % sf_n(aht); /* cycle iht index */
pctall[iht] = (pctall[iht]+1) % sf_n(aht);
}
if(it>=0+nht &&
it<nt-nht) {
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) \
private(ic, ihx,ihy,ihz,iht,mcx, mcy, mcz, mct, pcx, pcy, pcz, pct) \
shared (nc,ccin,ahx,ahy,ahz,aht,mcxall,mcyall,mczall,mctall,pcxall,pcyall,pczall,pctall)
#endif
for(ic=0;ic<nc;ic++){ if(ccin[ic]) { /* sum over c only! */
if(pos){
EICLOOP( wfl [mct][mcy][mcx][mcz] +=
opr [pct][pcy][pcx][pcz] *
img[ic][iht][ihy][ihx][ihz]; );
}else{
EICLOOP( wfl [pct][pcy][pcx][pcz] +=
opr [mct][mcy][mcx][mcz] *
img[ic][iht][ihy][ihx][ihz]; );
}
}
}
