int psp3(float **wvfld, float **wvfld1, float **dat, float **dat1, float *img, float *vel, pspar par)
/*< pseudo-spectral de-migration/migration >*/
{
/*survey parameters*/
int nx, nz;
float dx, dz;
int n_srcs;
int *spx, *spz;
int gpz, gpx, gpl;
int gpz_v, gpx_v, gpl_v;
int snap;
/*fft related*/
bool cmplx;
int pad1;
/*absorbing boundary*/
bool abc;
int nbt, nbb, nbl, nbr;
float ct,cb,cl,cr;
/*source parameters*/
int src; /*source type*/
int nt;
float dt,*f0,*t0,*A;
/*misc*/
bool verb, ps;
float vref;
int nx1, nz1; /*domain of interest*/
int it,iz,ik,ix,i,j; /* index variables */
int nk,nzx,nz2,nx2,nzx2,nkz,nth;
int it1, it2, its;
float dkx,dkz,kx0,kz0,vref2,kx,kz,k;
float c, old;
/*wave prop arrays*/
float *vv;
sf_complex *cwave,*cwavem;
float *wave,*curr,*curr1,*prev,*prev1,*lapl;
/*passing the parameters*/
nx = par->nx;
nz = par->nz;
dx = par->dx;
dz = par->dz;
n_srcs= par->n_srcs;
spx = par->spx;
spz = par->spz;
gpz = par->gpz;
gpx = par->gpx;
gpl = par->gpl;
gpz_v = par->gpz_v;
gpx_v = par->gpx_v;
gpl_v = par->gpl_v;
snap = par->snap;
cmplx = par->cmplx;
pad1 = par->pad1;
abc = par->abc;
nbt = par->nbt;
nbb = par->nbb;
nbl = par->nbl;
nbr = par->nbr;
ct = par->ct;
cb = par->cb;
cl = par->cl;
cr = par->cr;
src = par->src;
nt = par->nt;
dt = par->dt;
f0 = par->f0;
t0 = par->t0;
A = par->A;
verb = par->verb;
ps = par->ps;
vref = par->vref;
#ifdef _OPENMP
#pragma omp parallel
{
nth = omp_get_num_threads();
}
#else
nth = 1;
#endif
if (verb) sf_warning(">>>> Using %d threads <<<<<", nth);
nz1 = nz-nbt-nbb;
nx1 = nx-nbl-nbr;
nk = fft2_init(cmplx,pad1,nz,nx,&nz2,&nx2);
nzx = nz*nx;
nzx2 = nz2*nx2;
dkz = 1./(nz2*dz); kz0 = (cmplx)? -0.5/dz:0.;
dkx = 1./(nx2*dx); kx0 = -0.5/dx;
nkz = (cmplx)? nz2:(nz2/2+1);
if(nk!=nx2*nkz) sf_error("wavenumber dimension mismatch!");
sf_warning("dkz=%f,dkx=%f,kz0=%f,kx0=%f",dkz,dkx,kz0,kx0);
sf_warning("nk=%d,nkz=%d,nz2=%d,nx2=%d",nk,nkz,nz2,nx2);
if(abc)
abc_init(nz,nx,nz2,nx2,nbt,nbb,nbl,nbr,ct,cb,cl,cr);
/* allocate and read/initialize arrays */
vv = sf_floatalloc(nzx);
lapl = sf_floatalloc(nk);
wave = sf_floatalloc(nzx2);
curr = sf_floatalloc(nzx2);
curr1 = sf_floatalloc(nzx2);
prev = sf_floatalloc(nzx2);
prev1 = sf_floatalloc(nzx2);
cwave = sf_complexalloc(nk);
cwavem = sf_complexalloc(nk);
for (iz=0; iz < nzx; iz++) {
vv[iz] = vel[iz]*dt;
}
vref *= dt;
vref2 = vref*vref;
for (iz=0; iz < nzx2; iz++) {
curr[iz] = 0.;
curr1[iz] = 0.;
prev[iz] = 0.;
prev1[iz] = 0.;
}
for (iz=0; iz < nz1*nx1; iz++) {
img[iz] = 0.;
}
/* constructing the pseudo-analytical op */
for (ix=0; ix < nx2; ix++) {
kx = kx0+ix*dkx;
for (iz=0; iz < nkz; iz++) {
kz = kz0+iz*dkz;
k = 2*SF_PI*hypot(kx,kz);
if (ps) lapl[iz+ix*nkz] = -k*k;
else lapl[iz+ix*nkz] = 2.*(cos(vref*k)-1.)/vref2;
}
}
/* step backward in time */
it1 = nt-1;
it2 = -1;
its = -1;
/* MAIN LOOP */
for (it=it1; it!=it2; it+=its) {
if(verb) sf_warning("it=%d/%d;",it,nt);
/* inject data */
if (NULL!=dat) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix)
#endif
for (ix = 0; ix < gpl; ix++) {
curr[gpz+(ix+gpx)*nz2] += dat[ix][it];
}
}
if (NULL!=dat1) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix)
#endif
for (ix = 0; ix < gpl; ix++) {
curr1[gpz+(ix+gpx)*nz2] += dat1[ix][it];
}
}
/* first receiver wavefield */
/* matrix multiplication */
fft2(curr,cwave);
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*lapl[ik];
#else
cwavem[ik] = sf_cmul(cwave[ik],lapl[ik]);
#endif
}
ifft2(wave,cwavem);
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j,old,c)
#endif
for (ix = 0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
i = iz+ix*nz; /* original grid */
j = iz+ix*nz2; /* padded grid */
old = c = curr[j];
c += c - prev[j];
prev[j] = old;
c += wave[j]*vv[i]*vv[i];
curr[j] = c;
}
}
/*apply abc*/
if (abc) {
abc_apply(curr);
abc_apply(prev);
}
/* second receiver wavefield */
/* matrix multiplication */
fft2(curr1,cwave);
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*lapl[ik];
#else
cwavem[ik] = sf_cmul(cwave[ik],lapl[ik]);
#endif
}
ifft2(wave,cwavem);
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j,old,c)
#endif
for (ix = 0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
i = iz+ix*nz; /* original grid */
j = iz+ix*nz2; /* padded grid */
old = c = curr1[j];
c += c - prev1[j];
prev1[j] = old;
c += wave[j]*vv[i]*vv[i];
curr1[j] = c;
}
}
/*apply abc*/
if (abc) {
abc_apply(curr1);
abc_apply(prev1);
}
/* cross-correlation imaging condition */
if (snap > 0 && it%snap==0) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j)
#endif
for (ix = 0; ix < nx1; ix++) {
for (iz = 0; iz < nz1; iz++) {
i = iz + nz1*ix;
j = iz+nbt + (ix+nbl)*nz2; /* padded grid */
img[i] += curr[j]*curr1[j];
}
}
}
/* save wavefield */
if (snap > 0 && it%snap==0) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j)
#endif
for (ix=0; ix<nx1; ix++) {
for (iz=0; iz<nz1; iz++) {
i = iz + nz1*ix;
j = iz+nbt + (ix+nbl)*nz2; /* padded grid */
wvfld[it/snap][i] = curr[j];
wvfld1[it/snap][i] = curr1[j];
}
}
}
}
if(verb) sf_warning(".");
/*free up memory*/
fft2_finalize();
if (abc) abc_close();
free(vv);
free(lapl);
free(wave);
free(curr);
free(curr1);
free(prev);
free(prev1);
free(cwave);
free(cwavem);
return 0;
}
int mcfft3_init(int pad1 /* padding on the first axis */,
int nx, int ny, int nz /* input data size */,
int *nx2, int *ny2, int *nz2 /* padded data size */,
int *n_local, int *o_local /* local size & start */)
/*< initialize >*/
{
int i, nth=1;
int cpuid;
MPI_Comm_rank(MPI_COMM_WORLD, &cpuid);
fftwf_mpi_init();
/* axis 1 */
nk = n1 = kiss_fft_next_fast_size(nx*pad1);
/* axis 2 */
n2 = kiss_fft_next_fast_size(ny);
/* axis 3 */
n3 = kiss_fft_next_fast_size(nz);
alloc_local = fftwf_mpi_local_size_2d_transposed(n3, n2*n1, MPI_COMM_WORLD, &local_n0, &local_0_start, &local_n1, &local_1_start);
cc = sf_complexalloc(n1*n2*local_n0);
/* kiss-fft */
#ifdef _OPENMP
#pragma omp parallel
{nth = omp_get_num_threads();}
#endif
cfg1 = (kiss_fft_cfg *) sf_alloc(nth,sizeof(kiss_fft_cfg));
icfg1 = (kiss_fft_cfg *) sf_alloc(nth,sizeof(kiss_fft_cfg));
cfg2 = (kiss_fft_cfg *) sf_alloc(nth,sizeof(kiss_fft_cfg));
icfg2 = (kiss_fft_cfg *) sf_alloc(nth,sizeof(kiss_fft_cfg));
cfg3 = (kiss_fft_cfg *) sf_alloc(nth,sizeof(kiss_fft_cfg));
icfg3 = (kiss_fft_cfg *) sf_alloc(nth,sizeof(kiss_fft_cfg));
for (i=0; i < nth; i++) {
cfg1[i] = kiss_fft_alloc(n1,0,NULL,NULL);
icfg1[i]= kiss_fft_alloc(n1,1,NULL,NULL);
cfg2[i] = kiss_fft_alloc(n2,0,NULL,NULL);
icfg2[i]= kiss_fft_alloc(n2,1,NULL,NULL);
cfg3[i] = kiss_fft_alloc(n3,0,NULL,NULL);
icfg3[i]= kiss_fft_alloc(n3,1,NULL,NULL);
}
ctrace2= (kiss_fft_cpx **) sf_complexalloc2(n2,nth);
ctrace3= (kiss_fft_cpx **) sf_complexalloc2(n3,nth);
//tmp = (kiss_fft_cpx *) sf_complexalloc(alloc_local);
tmp = (kiss_fft_cpx *) sf_alloc(alloc_local,sizeof(kiss_fft_cpx));
tmp2= (sf_complex *) tmp;
/* fftw for transpose */
cfg = fftwf_mpi_plan_many_transpose(n3,n2*n1,2,
FFTW_MPI_DEFAULT_BLOCK,FFTW_MPI_DEFAULT_BLOCK,
(float *) tmp,
(float *) tmp,
MPI_COMM_WORLD,
FFTW_MEASURE);
icfg= fftwf_mpi_plan_many_transpose(n2*n1,n3,2,
FFTW_MPI_DEFAULT_BLOCK,FFTW_MPI_DEFAULT_BLOCK,
(float *) tmp,
(float *) tmp,
MPI_COMM_WORLD,
FFTW_MEASURE);
if (NULL == cfg || NULL == icfg) sf_error("FFTW failure.");
*nx2 = n1;
*ny2 = n2;
*nz2 = n3;
*n_local = (int) local_n0;
*o_local = (int) local_0_start;
wt = 1.0/(n3*n2*n1);
return (nk*n2*n3);
}
int main(int argc, char* argv[])
{
int i, iter, niter;
sf_complex *buf, *buf2;
double rn, rnp, alpha, beta;
off_t nm, nd, msiz, dsiz, pos;
size_t nbuf, mbuf, dbuf, len, iolen, cmdlen;
FILE *xfile, *Rfile, *gfile, *Gfile, *sfile, *Sfile;
char *x, *R, *g, *G, *s, *S, *prog, *cmdline, *iostring, *arg;
sf_file mod, dat, x0; /* input */
sf_file Rrsf, Grsf, grsf, out; /* output */
extern int fseeko(FILE *stream, off_t offset, int whence);
extern off_t ftello (FILE *stream);
sf_init(argc,argv);
dat = sf_input("--input");
mod = sf_input("mod");
out = sf_output("--output");
sf_fileflush(out,mod);
sf_settype(out,SF_COMPLEX);
if (SF_COMPLEX != sf_gettype(mod) ||
SF_COMPLEX != sf_gettype(dat))
sf_error("Need complex type in mod and dat");
for (i=0; i < argc-1; i++) {
argv[i]=argv[i+1];
}
for (i=0; i < argc-1; i++) {
/* find the program to run */
if (NULL == strchr(argv[i],'=')) {
/* first one without the '=' */
prog = argv[0];
argv[0] = argv[i];
argv[i] = prog;
break;
}
}
argv[argc-1] = sf_charalloc(6);
snprintf(argv[argc-1],6,"adj=X");
if (!sf_getint("niter",&niter)) niter=1;
/* number of iterations */
Rfile = sf_tempfile(&R,"w+");
xfile = sf_tempfile(&x,"w+b");
gfile = sf_tempfile(&g,"w+");
Gfile = sf_tempfile(&G,"w+");
sfile = sf_tempfile(&s,"w+b");
Sfile = sf_tempfile(&S,"w+b");
fclose(Rfile); Rrsf = sf_output(R); sf_readwrite(Rrsf,true); sf_fileflush(Rrsf,dat);
fclose(xfile);
fclose(gfile);
fclose(Gfile);
fclose(sfile);
fclose(Sfile);
nm = sf_filesize(mod);
nd = sf_filesize(dat);
/* I/O buffers */
nbuf = BUFSIZ/sizeof(sf_complex);
buf = sf_complexalloc(nbuf);
buf2 = sf_complexalloc(nbuf);
cmdline = sf_charalloc(SF_CMDLEN);
iostring = sf_charalloc(SF_CMDLEN);
cmdlen = 0;
for (i=0; i < argc; i++) {
arg = argv[i];
len = strlen(arg);
if (cmdlen+len > SF_CMDLEN-2) sf_error("command line is too long");
strncpy(cmdline+cmdlen,arg,len);
cmdline[cmdlen+len]=' ';
cmdlen += len+1;
}
if (NULL != sf_getstring("x0")) {
x0 = sf_input("x0"); /* initial model */
} else {
x0 = NULL;
}
for (iter=0; iter < niter; iter++) {
if (0 == iter) {
xfile = fopen(x,"wb");
if (NULL == x0) {
for (i=0; i < nbuf; i++) { buf[i] = sf_cmplx(0.0f,0.0f); }
}
MLOOP( if (NULL != x0) sf_complexread(buf,mbuf,x0);
MWRITE(xfile); );
fclose(xfile);
#ifdef SF_HAS_COMPLEX_H
DLOOP( sf_complexread(buf,dbuf,dat);
for (i=0; i < dbuf; i++) { buf[i] = -buf[i]; }
sf_complexwrite(buf,dbuf,Rrsf); );
int lrosback2(sf_complex **img, sf_complex ***wavfld, float **sill, sf_complex **rcd, bool adj,
bool verb, bool wantwf, sf_complex **lt, sf_complex **rt, int m2,
geopar geop, int pad1, bool illum)
/*< low-rank one-step backward propagation + imaging >*/
{
int it,iz,im,ik,ix,i,j; /* index variables */
int nxb,nzb,gpz,gpx,gpl,snpint,wfit;
int nt,nz,nx, nk, nz2, nx2, nzx2;
sf_complex c;
sf_complex *cwave, *cwavem, *currm;
sf_complex **wave, *curr;
sf_complex **ccr;
nx = geop->nx;
nz = geop->nz;
nxb = geop->nxb;
nzb = geop->nzb;
/* dx = geop->dx;
dz = geop->dz; */
gpz = geop->gpz;
gpx = geop->gpx;
gpl = geop->gpl;
snpint = geop->snpint;
nt = geop->nt;
/* dt = geop->dt; */
ccr = sf_complexalloc2(nz, nx);
nk = cfft2_init(pad1,nzb,nxb,&nz2,&nx2);
/* nzx = nzb*nxb; */
nzx2 = nz2*nx2;
curr = sf_complexalloc(nzx2);
cwave = sf_complexalloc(nk);
wave = sf_complexalloc2(nzx2,m2);
if (!adj) {
currm = sf_complexalloc(nzx2);
icfft2_allocate(cwave);
} else {
cwavem = sf_complexalloc(nk);
icfft2_allocate(cwavem);
}
#ifdef _OPENMP
#pragma omp parallel for private(iz)
#endif
for (iz=0; iz < nzx2; iz++) {
curr[iz] = sf_cmplx(0.,0.);
}
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for (ix = 0; ix < nx; ix++) {
for (iz = 0; iz < nz; iz++) {
ccr[ix][iz] = sf_cmplx(0.,0.);
}
}
if (adj) { /* migration */
/* step backward in time (PSPI) */
/*Main loop*/
wfit = (int)(nt-1)/snpint;
for (it = nt-1; it>=0; it--) {
if (verb) sf_warning("Backward receiver it=%d/%d;", it, nt-1);
#ifdef _OPENMP
#pragma omp parallel for private(ix,j)
#endif
for (ix=0; ix<gpl; ix++) {
j = (gpz+geop->top)+(ix+gpx+geop->lft)*nz2; /* padded grid */
#ifdef SF_HAS_COMPLEX_H
curr[j]+=rcd[ix][it]; /* data injection */
#else
curr[j]=sf_cadd(curr[j],rcd[ix][it]);
#endif
}
/*matrix multiplication*/
cfft2(curr,cwave);
for (im = 0; im < m2; 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,lt,wave)
#endif
for (ix = 0; ix < nxb; ix++) {
for (iz=0; iz < nzb; iz++) {
i = iz+ix*nzb; /* original grid */
j = iz+ix*nz2; /* padded grid */
c = sf_cmplx(0.,0.); // initialize
for (im = 0; im < m2; im++) {
#ifdef SF_HAS_COMPLEX_H
c += lt[im][i]*wave[im][j];
#else
c = sf_cadd(c,sf_cmul(lt[im][i], wave[im][j]));
#endif
}
curr[j] = c;
}
}
/*cross-correlation imaging condition*/
if (it%snpint == 0 ) {
#ifdef _OPENMP
#pragma omp parallel for private(ix,iz,j)
#endif
for (ix=0; ix<nx; ix++) {
for (iz=0; iz<nz; iz++) {
j = (iz+geop->top)+(ix+geop->lft)*nz2; /* padded grid */
#ifdef SF_HAS_COMPLEX_H
ccr[ix][iz] += conjf(wavfld[wfit][ix][iz])*curr[j];
#else
ccr[ix][iz] = sf_cadd(ccr[ix][iz],sf_cmul(conjf(wavfld[wfit][ix][iz]),curr[j]));
#endif
}
}
wfit--;
}
} /*Main loop*/
if (verb) sf_warning(".");
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for (ix=0; ix<nx; ix++) {
for (iz=0; iz<nz; iz++) {
if (illum) {
#ifdef SF_HAS_COMPLEX_H
img[ix][iz] = ccr[ix][iz]/(sill[ix][iz]+SF_EPS);
#else
img[ix][iz] = sf_crmul(ccr[ix][iz],1./(sill[ix][iz]+SF_EPS));
#endif
} else img[ix][iz] = ccr[ix][iz];
}
}
} else { /* modeling */
/* adjoint of source illumination */
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for (ix=0; ix<nx; ix++) {
for (iz=0; iz<nz; iz++) {
if (illum) {
#ifdef SF_HAS_COMPLEX_H
ccr[ix][iz] = img[ix][iz]/(sill[ix][iz]+SF_EPS);
#else
ccr[ix][iz] = sf_crmul(img[ix][iz],1./(sill[ix][iz]+SF_EPS));
#endif
} else ccr[ix][iz] = img[ix][iz];
}
}
/* step forward in time (NSPS) */
/*Main loop*/
wfit=0;
for (it=0; it<nt; it++) {
if (verb) sf_warning("Forward receiver it=%d/%d;", it, nt-1);
/*adjoint of cross-correlation imaging condition*/
if (it%snpint == 0 ) {
#ifdef _OPENMP
#pragma omp parallel for private(ix,iz,j)
#endif
for (ix=0; ix<nx; ix++) {
for (iz=0; iz<nz; iz++) {
j = (iz+geop->top)+(ix+geop->lft)*nz2; /* padded grid */
#ifdef SF_HAS_COMPLEX_H
curr[j] += (wavfld[wfit][ix][iz])*ccr[ix][iz];/* adjoint of ccr[ix][iz] += conjf(wavfld[wfit][ix][iz])*curr[j]; ??? */
#else
curr[j] = sf_cadd(curr[j],sf_cmul((wavfld[wfit][ix][iz]),ccr[ix][iz]));
#endif
}
}
wfit++;
}
/*matrix multiplication*/
for (im = 0; im < m2; im++) {
#ifdef _OPENMP
#pragma omp parallel for private(ix,iz,i,j) shared(currm,lt,curr)
#endif
for (ix = 0; ix < nxb; ix++) {
for (iz=0; iz < nzb; iz++) {
i = iz+ix*nzb; /* original grid */
j = iz+ix*nz2; /* padded grid */
#ifdef SF_HAS_COMPLEX_H
currm[j] = conjf(lt[im][i])*curr[j];
#else
currm[j] = sf_cmul(conjf(lt[im][i]), curr[j]);
#endif
}
}
cfft2(currm,wave[im]);
}
#ifdef _OPENMP
#pragma omp parallel for private(ik,im,c) shared(wave,rt,cwave)
#endif
for (ik = 0; ik < nk; ik++) {
c = sf_cmplx(0.,0.);
for (im = 0; im < m2; im++) {
#ifdef SF_HAS_COMPLEX_H
c += wave[im][ik]*conjf(rt[ik][im]);
#else
c = sf_cadd(c,sf_cmul(wave[im][ik],conjf(rt[ik][im])));
#endif
}
cwave[ik] = c;
}
icfft2(curr,cwave);
#ifdef _OPENMP
#pragma omp parallel for private(ix,j)
#endif
for (ix=0; ix<gpl; ix++) {
j = (gpz+geop->top)+(ix+gpx+geop->lft)*nz2; /* padded grid */
rcd[ix][it]=curr[j];
}
} /*Main loop*/
}
cfft2_finalize();
return 0;
}
int main(int argc, char* argv[])
{
bool mig, sub;
int it, nt, ix, nx, iz, nz, nx2, nz2, nzx, nzx2, ih, nh, nh2;
int im, i, j, m2, it1, it2, its, ikz, ikx, ikh, n2, nk, snap;
float dt, dx, dz, c, old, dh;
float *curr, *prev, **img, **dat, **lft, **rht, **wave;
sf_complex *cwave, *cwavem;
sf_file data, image, left, right, snaps;
/*MPI related*/
int cpuid,numprocs;
int provided;
int n_local, o_local, nz_local;
int ozx2;
float *sendbuf, *recvbuf, *wave_all;
int *rcounts, *displs;
/*wall time*/
double startTime, elapsedTime;
double clockZero = 0.0;
MPI_Init_thread(&argc,&argv,MPI_THREAD_FUNNELED,&provided);
threads_ok = provided >= MPI_THREAD_FUNNELED;
sf_init(argc,argv);
MPI_Comm_rank(MPI_COMM_WORLD, &cpuid);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
if (!sf_getbool("mig",&mig)) mig=false;
/* if n, modeling; if y, migration */
if (!sf_getint("snap",&snap)) snap=0;
/* interval for snapshots */
snaps = (snap > 0)? sf_output("snaps"): NULL;
/* (optional) snapshot file */
if (mig) { /* migration */
data = sf_input("input");
image = sf_output("output");
if (!sf_histint(data,"n1",&nh)) sf_error("No n1=");
if (!sf_histfloat(data,"d1",&dh)) sf_error("No d1=");
if (!sf_histint(data,"n2",&nx)) sf_error("No n2=");
if (!sf_histfloat(data,"d2",&dx)) sf_error("No d2=");
if (!sf_histint(data,"n3",&nt)) sf_error("No n3=");
if (!sf_histfloat(data,"d3",&dt)) sf_error("No d3=");
if (!sf_getint("nz",&nz)) sf_error("Need nz=");
/* time samples (if migration) */
if (!sf_getfloat("dz",&dz)) sf_error("Need dz=");
/* time sampling (if migration) */
if (cpuid==0) {
sf_putint(image,"o1",0.);
sf_putint(image,"n1",nz);
sf_putfloat(image,"d1",dz);
sf_putstring(image,"label1","Depth");
sf_putint(image,"o2",0.);
sf_putint(image,"n2",nx);
sf_putfloat(image,"d2",dx);
sf_putstring(image,"label2","Midpoint");
sf_putint(image,"n3",1); /* stack for now */
}
} else { /* modeling */
image = sf_input("input");
data = sf_output("output");
if (!sf_histint(image,"n1",&nz)) sf_error("No n1=");
if (!sf_histfloat(image,"d1",&dz)) sf_error("No d1=");
if (!sf_histint(image,"n2",&nx)) sf_error("No n2=");
if (!sf_histfloat(image,"d2",&dx)) sf_error("No d2=");
if (!sf_getint("nt",&nt)) sf_error("Need nt=");
/* time samples (if modeling) */
if (!sf_getfloat("dt",&dt)) sf_error("Need dt=");
/* time sampling (if modeling) */
if (!sf_getint("nh",&nh)) sf_error("Need nh=");
/* offset samples (if modeling) */
if (!sf_getfloat("dh",&dh)) sf_error("Need dh=");
/* offset sampling (if modeling) */
if (cpuid==0) {
sf_putint(data,"n1",nh);
sf_putfloat(data,"d1",dh);
sf_putstring(data,"label1","Half-Offset");
sf_putint(data,"o2",0.);
sf_putint(data,"n2",nx);
sf_putfloat(data,"d2",dx);
sf_putstring(data,"label2","Midpoint");
sf_putint(data,"n3",nt);
sf_putfloat(data,"d3",dt);
sf_putstring(data,"label3","Time");
sf_putstring(data,"unit3","s");
}
}
if (cpuid==0) {
if (NULL != snaps) {
sf_putint(snaps,"n1",nh);
sf_putfloat(snaps,"d1",dh);
sf_putstring(snaps,"label1","Half-Offset");
sf_putint(snaps,"n2",nx);
sf_putfloat(snaps,"d2",dx);
sf_putstring(snaps,"label2","Midpoint");
sf_putint(snaps,"n3",nz);
sf_putfloat(snaps,"d3",dz);
sf_putstring(snaps,"label3","Depth");
sf_putint(snaps,"n4",nt/snap);
sf_putfloat(snaps,"d4",dt*snap);
if (mig) {
sf_putfloat(snaps,"o4",(nt-1)*dt);
} else {
sf_putfloat(snaps,"o4",0.);
}
sf_putstring(snaps,"label4","Time");
}
}
/* Mark the starting time. */
startTime = walltime( &clockZero );
nk = mcfft3_init(1,nh,nx,nz,&nh2,&nx2,&nz2,&n_local,&o_local);
nz_local = (n_local < nz-o_local)? n_local:nz-o_local;
sf_warning("Cpuid=%d,n2=%d,n1=%d,n0=%d,local_n0=%d,local_0_start=%d,nz_local=%d",cpuid,nh2,nx2,nz2,n_local,o_local,nz_local);
if (cpuid==0)
if (o_local!=0) sf_error("Cpuid and o_local inconsistant!");
nzx = nz*nx*nh;
//nzx2 = nz2*nx2*nh2;
nzx2 = n_local*nx2*nh2;
ozx2 = o_local*nx2*nh2;
img = sf_floatalloc2(nz,nx);
dat = sf_floatalloc2(nh,nx);
/* propagator matrices */
left = sf_input("left");
right = sf_input("right");
if (!sf_histbool(left,"sub",&sub) && !sf_getbool("sub",&sub)) sub=true;
/* if -1 is included in the matrix */
if (!sf_histint(left,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in left",nzx);
if (!sf_histint(left,"n2",&m2)) sf_error("No n2= in left");
if (!sf_histint(right,"n1",&n2) || n2 != m2) sf_error("Need n1=%d in right",m2);
if (!sf_histint(right,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in right",nk);
lft = sf_floatalloc2(nzx,m2);
rht = sf_floatalloc2(m2,nk);
sf_floatread(lft[0],nzx*m2,left);
sf_floatread(rht[0],m2*nk,right);
curr = sf_floatalloc(nzx2);
prev = sf_floatalloc(nzx2);
cwave = sf_complexalloc(nk);
cwavem = sf_complexalloc(nk);
wave = sf_floatalloc2(nzx2,m2);
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(iz)
#endif
for (iz=0; iz < nzx2; iz++) {
curr[iz]=0.;
prev[iz]=0.;
}
sendbuf = prev;
if (cpuid==0) {
wave_all = sf_floatalloc(nh2*nx2*nz2);
recvbuf = wave_all;
rcounts = sf_intalloc(numprocs);
displs = sf_intalloc(numprocs);
} else {
wave_all = NULL;
recvbuf = NULL;
rcounts = NULL;
displs = NULL;
}
MPI_Gather(&nzx2, 1, MPI_INT, rcounts, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Gather(&ozx2, 1, MPI_INT, displs, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (mig) { /* migration */
/* step backward in time */
it1 = nt-1;
it2 = -1;
its = -1;
} else { /* modeling */
sf_floatread(img[0],nz*nx,image);
/* transpose and initialize at zero offset */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(iz,ix)
#endif
for (iz=0; iz < nz_local; iz++) {
for (ix=0; ix < nx; ix++) {
curr[nh2*(ix+iz*nx2)]=img[ix][iz+o_local];
}
}
/* step forward in time */
it1 = 0;
it2 = nt;
its = +1;
}
/* time stepping */
for (it=it1; it != it2; it += its) {
sf_warning("it=%d;",it);
if (mig) { /* migration <- read data */
sf_floatread(dat[0],nx*nh,data);
} else {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,ih)
#endif
for (ix=0; ix < nx; ix++) {
for (ih=0; ih < nh; ih++) {
dat[ix][ih] = 0.;
}
}
}
if (NULL != snaps && 0 == it%snap) {
MPI_Gatherv(sendbuf, nzx2, MPI_FLOAT, recvbuf, rcounts, displs, MPI_FLOAT, 0, MPI_COMM_WORLD);
if (cpuid==0) {
for (iz = 0; iz < nz; iz++)
for (ix = 0; ix < nx; ix++)
sf_floatwrite(wave_all+nh2*(ix+nx2*iz),nh,snaps);
}
}
/* at z=0 */
if (cpuid==0) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,ih)
#endif
for (ix=0; ix < nx; ix++) {
for (ih=0; ih < nh; ih++) {
if (mig) {
curr[ix*nh2+ih] += dat[ix][ih];
} else {
dat[ix][ih] = curr[ix*nh2+ih];
}
}
}
}
/* matrix multiplication */
mcfft3(curr,cwave);
for (im = 0; im < m2; im++) {
//for (ik = 0; ik < nk; ik++) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ikz,ikx,ikh,i,j)
#endif
for (ikz = 0; ikz < n_local; ikz++) {
for (ikx = 0; ikx < nx2; ikx++) {
for (ikh = 0; ikh < nh2; ikh++) {
i = ikh + ikx*nh2 + (o_local+ikz)*nx2*nh2;
j = ikh + ikx*nh2 + ikz*nx2*nh2;
#ifdef SF_HAS_COMPLEX_H
cwavem[j] = cwave[j]*rht[i][im];
#else
cwavem[j] = sf_crmul(cwave[j],rht[i][im]);
#endif
}
}
}
imcfft3(wave[im],cwavem);
}
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,ih,i,j,im,old,c)
#endif
for (iz=0; iz < nz_local; iz++) {
for (ix = 0; ix < nx; ix++) {
for (ih=0; ih < nh; ih++) {
i = ih + ix*nh + (o_local+iz)*nx*nh; /* original grid */
j = ih + ix*nh2+ iz*nx2*nh2; /* padded grid */
old = curr[j];
c = sub? 2*old: 0.0f;
c -= prev[j];
prev[j] = old;
for (im = 0; im < m2; im++) {
c += lft[im][i]*wave[im][j];
}
curr[j] = c;
}
}
}
if (!mig) { /* modeling -> write out data */
if (cpuid==0)
sf_floatwrite(dat[0],nx*nh,data);
}
}
sf_warning(".");
if (mig) {
sendbuf = curr;
MPI_Gatherv(sendbuf, nzx2, MPI_FLOAT, recvbuf, rcounts, displs, MPI_FLOAT, 0, MPI_COMM_WORLD);
if (cpuid==0) {
/* transpose */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(iz,ix)
#endif
for (iz=0; iz < nz; iz++) {
for (ix=0; ix < nx; ix++) {
img[ix][iz] = wave_all[nh2*(ix+iz*nx2)];
}
}
sf_floatwrite(img[0],nz*nx,image);
}
}
mcfft3_finalize();
/* Work's done. Get the elapsed wall time. */
elapsedTime = walltime( &startTime );
/* Print the wall time and terminate. */
if (cpuid==0)
printf("\nwall time = %.5fs\n", elapsedTime);
MPI_Finalize();
exit(0);
}
int main(int argc, char* argv[])
{
bool verb;
int it,iz,im,ik,ix,iy,i,j, snap; /* index variables */
int nt,nz,nx,ny, m2, nk, nzx, nz2, nx2, ny2, nzx2, n2, pad1;
float dt;
sf_complex c;
float *rr; /* I/O arrays*/
sf_complex *cwave, *cwavem, *ww;
sf_complex **wave, *curr;
float *rcurr;
sf_file Fw,Fr,Fo; /* I/O files */
sf_axis at,az,ax,ay; /* cube axes */
sf_complex **lt, **rt;
sf_file left, right, snaps;
sf_init(argc,argv);
if(!sf_getbool("verb",&verb)) verb=true; /* verbosity */
/* setup I/O files */
Fw = sf_input ("in" );
Fo = sf_output("out");
Fr = sf_input ("ref");
/* Read/Write axes */
at = sf_iaxa(Fw,1); nt = sf_n(at); dt = sf_d(at);
az = sf_iaxa(Fr,1); nz = sf_n(az);
ax = sf_iaxa(Fr,2); nx = sf_n(ax);
ay = sf_iaxa(Fr,3); ny = sf_n(ay);
sf_oaxa(Fo,az,1);
sf_oaxa(Fo,ax,2);
sf_oaxa(Fo,ay,3);
sf_settype(Fo,SF_FLOAT);
if (!sf_getint("pad1",&pad1)) pad1=1; /* padding factor on the first axis */
if (!sf_getint("snap",&snap)) snap=0;
/* interval for snapshots */
if (snap > 0) {
snaps = sf_output("snaps");
/* (optional) snapshot file */
sf_oaxa(snaps,az,1);
sf_oaxa(snaps,ax,2);
sf_oaxa(snaps,ay,3);
sf_oaxa(snaps,at,4);
sf_settype(snaps,SF_FLOAT);
sf_putint(snaps,"n4",nt/snap);
sf_putfloat(snaps,"d4",dt*snap);
sf_putfloat(snaps,"o4",0.);
} else {
snaps = NULL;
}
nk = cfft3_init(pad1,nz,nx,ny,&nz2,&nx2,&ny2);
nzx = nz*nx*ny;
nzx2 = nz2*nx2*ny2;
/* propagator matrices */
left = sf_input("left");
right = sf_input("right");
if (!sf_histint(left,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in left",nzx);
if (!sf_histint(left,"n2",&m2)) sf_error("Need n2=%d in left",m2);
if (!sf_histint(right,"n1",&n2) || n2 != m2) sf_error("Need n1=%d in right",m2);
if (!sf_histint(right,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in right",nk);
lt = sf_complexalloc2(nzx,m2);
rt = sf_complexalloc2(m2,nk);
sf_complexread(lt[0],nzx*m2,left);
sf_complexread(rt[0],m2*nk,right);
/* read wavelet & reflectivity */
ww=sf_complexalloc(nt); sf_complexread(ww,nt ,Fw);
rr=sf_floatalloc(nzx); sf_floatread(rr,nzx,Fr);
curr = sf_complexalloc(nzx2);
rcurr= sf_floatalloc(nzx2);
cwave = sf_complexalloc(nk);
cwavem = sf_complexalloc(nk);
wave = sf_complexalloc2(nzx2,m2);
icfft3_allocate(cwavem);
for (iz=0; iz < nzx2; iz++) {
curr[iz]=sf_cmplx(0.,0.);
rcurr[iz]=0.;
}
/* MAIN LOOP */
for (it=0; it<nt; it++) {
if(verb) sf_warning("it=%d;",it);
/* matrix multiplication */
cfft3(curr,cwave);
for (im = 0; im < m2; im++) {
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
}
icfft3(wave[im],cwavem);
}
for (iy = 0; iy < ny; iy++) {
for (ix = 0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
i = iz+nz *(ix+nx *iy); /* original grid */
j = iz+nz2*(ix+nx2*iy); /* padded grid */
#ifdef SF_HAS_COMPLEX_H
c = ww[it] * rr[i];
#else
c = sf_crmul(ww[it],rr[i]);
#endif
for (im = 0; im < m2; 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;
rcurr[j]= crealf(c);
}
}
}
if (NULL != snaps && 0 == it%snap) {
for (iy = 0; iy < ny; iy++) {
for (ix = 0; ix < nx; ix++) {
sf_floatwrite(rcurr+nz2*(ix+nx2*iy),nz,snaps);
}
}
}
}
if(verb) sf_warning(".");
/* write wavefield to output */
for (iy = 0; iy < ny; iy++) {
for (ix = 0; ix < nx; ix++) {
sf_floatwrite(rcurr+nz2*(ix+nx2*iy),nz,Fo);
}
}
cfft3_finalize();
exit (0);
}
int main(int argc, char* argv[])
{
map4 str;
bool verb;
int i1,i2, n1,n2,n3, nw, nx,nv, ix,iv, iy,ny;
float d1,o1,d2,o2, eps, w,x, v0,v2,v,dv, dx, t, x0, dw;
float *trace, *strace, *t2;
sf_complex *ctrace, *ctrace2, shift;
sf_file in, out;
#ifdef SF_HAS_FFTW
fftwf_plan forw, invs;
#else
kiss_fftr_cfg forw, invs;
#endif
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&nx)) sf_error("No n2= in input");
ny = sf_leftsize(in,2);
if (!sf_getfloat("eps",&eps)) eps=0.01; /* regularization */
if (!sf_getint("pad",&n2)) n2=n1; /* padding for stretch */
if (!sf_getint("pad2",&n3)) n3=2*kiss_fft_next_fast_size((n2+1)/2);
/* padding for FFT */
if (!sf_getbool("verb",&verb)) verb=true;
/* verbosity flag */
nw = n3/2+1;
strace = sf_floatalloc(n3);
ctrace = sf_complexalloc(nw);
ctrace2 = sf_complexalloc(nw);
#ifdef SF_HAS_FFTW
forw = fftwf_plan_dft_r2c_1d(n3, strace, (fftwf_complex *) ctrace,
FFTW_ESTIMATE);
invs = fftwf_plan_dft_c2r_1d(n3, (fftwf_complex *) ctrace2, strace,
FFTW_ESTIMATE);
#else
forw = kiss_fftr_alloc(n3,0,NULL,NULL);
invs = kiss_fftr_alloc(n3,1,NULL,NULL);
#endif
if (NULL == forw || NULL == invs) sf_error("FFT allocation error");
if (!sf_histfloat(in,"o1",&o1)) o1=0.;
o2 = o1*o1;
if(!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input");
d2 = o1+(n1-1)*d1;
d2 = (d2*d2 - o2)/(n2-1);
dw = 16*SF_PI/(d2*n3); /* 2pi * 8 */
if (!sf_getint("nv",&nv)) sf_error("Need nv=");
/* velocity steps */
if (!sf_getfloat("dv",&dv)) sf_error("Need dv=");
/* velocity step size */
if (!sf_getfloat("v0",&v0) &&
!sf_histfloat(in,"v0",&v0)) sf_error("Need v0=");
/*( v0 starting velocity )*/
if(!sf_histfloat(in,"d2",&dx)) sf_error("No d2= in input");
if(!sf_histfloat(in,"o2",&x0)) x0=0.;
sf_putfloat(out,"o2",v0+dv);
sf_putfloat(out,"d2",dv);
sf_putint(out,"n2",nv);
sf_putstring(out,"label2","Velocity");
sf_shiftdim(in, out, 2);
dx *= 2.*SF_PI;
x0 *= 2.*SF_PI;
trace = sf_floatalloc(n1);
t2 = sf_floatalloc(n2);
str = stretch4_init (n1, o1, d1, n2, eps);
for (i2=0; i2 < n2; i2++) {
t = o2+i2*d2;
t2[i2] = sqrtf(t);
}
stretch4_define (str,t2);
for (iy=0; iy < ny; iy++) {
for (ix=0; ix < nx; ix++) {
if (verb) sf_warning("wavenumber %d of %d (%d);", ix+1,nx,iy);
x = x0+ix*dx;
x *= x;
x *= 0.5;
sf_floatread(trace,n1,in);
for (i1=0; i1 < n1; i1++) {
trace[i1] /= n1;
}
stretch4_invert (false,str,strace,trace);
for (i2=n2; i2 < n3; i2++) {
strace[i2] = 0.;
}
#ifdef SF_HAS_FFTW
fftwf_execute(forw);
#else
kiss_fftr(forw,strace, (kiss_fft_cpx *) ctrace);
#endif
for (iv=0; iv < nv; iv++) {
v = v0 + (iv+1)*dv;
v2 = x * ((v0*v0) - (v*v));
ctrace2[0] = sf_cmplx(0.0f,0.0f); /* dc */
for (i2=1; i2 < nw; i2++) {
w = i2*dw;
w = v2/w;
shift = sf_cmplx(cosf(w),sinf(w));
#ifdef SF_HAS_COMPLEX_H
ctrace2[i2] = ctrace[i2] * shift;
#else
ctrace2[i2] = sf_cmul(ctrace[i2],shift);
#endif
} /* w */
#ifdef SF_HAS_FFTW
fftwf_execute(invs);
#else
kiss_fftri(invs,(const kiss_fft_cpx *) ctrace2, strace);
#endif
stretch4_apply(false,str,strace,trace);
sf_floatwrite (trace,n1,out);
} /* v */
} /* x */
if (verb) sf_warning(".");
} /* y */
exit (0);
}
void ocpredict_step(bool adj /* adjoint flag */,
bool forw /* forward or backward */,
float dw, int nx,
float w /* log-stretch frequency */,
float h, float h2 /* offset position */,
sf_complex *trace /* common offset slice */)
/*< offset continuation prediction step >*/
{
int ix, k;
float w2;
sf_complex diag, diag2, *in, offd, offd2, c1, c2;
ctris slv;
in = sf_complexalloc(nx);
slv = ctridiagonal_init (nx);
w2 = w*w;
if (fabsf(w) < dw) {
return;
/* for (ix=0; ix < nx; ix++) {
trace[ix]=sf_cmplx(0.,0.);
}
*/ }
#ifdef SF_HAS_COMPLEX_H
c1 = 3.*sf_cmplx(9. + w2,4.*w)/(w2*sf_cmplx(3.,- w));
c2 = 3.*sf_cmplx(w2 - 27.,8.*w)/(w2*sf_cmplx(3.,- w));
#else
c1 = sf_cdiv(sf_cmplx(3.*(9. + w2),3.*4.*w),
sf_cmplx(w2*3.,-w2*w));
c2 = sf_cdiv(sf_cmplx(3.*(w2 - 27.),3.*8.*w),
sf_cmplx(w2*3.,-w2*w));
#endif
for (ix=0; ix < nx; ix++) {
in[ix] = trace[ix];
}
h *= h;
h2 *= h2;
if (forw) {
#ifdef SF_HAS_COMPLEX_H
offd = 1. - c1*h2 + c2*h;
offd2 = 1. - c1*h + c2*h2;
diag = 12. - 2.*offd;
diag2 = 12. - 2.*offd2;
#else
offd = sf_cadd(sf_cmplx(1.,0.),
sf_cadd(sf_crmul(c1,-h2),
sf_crmul(c2,h)));
offd2 = sf_cadd(sf_cmplx(1.,0.),
sf_cadd(sf_crmul(c1,-h),
sf_crmul(c2,h2)));
diag = sf_cadd(sf_cmplx(12.,0.),sf_crmul(offd,-2.));
diag2 = sf_cadd(sf_cmplx(12.,0.),sf_crmul(offd2,-2.));
#endif
} else {
#ifdef SF_HAS_COMPLEX_H
offd = 1. - c1*h + c2*h2;
offd2 = 1. - c1*h2 + c2*h;
diag = 12. - 2.*offd;
diag2 = 12. - 2.*offd2;
#else
offd = sf_cadd(sf_cmplx(1.,0.),
sf_cadd(sf_crmul(c1,-h),
sf_crmul(c2,h2)));
offd2 = sf_cadd(sf_cmplx(1.,0.),
sf_cadd(sf_crmul(c1,-h2),
sf_crmul(c2,h)));
diag = sf_cadd(sf_cmplx(12.,0.),sf_crmul(offd,-2.));
diag2 = sf_cadd(sf_cmplx(12.,0.),sf_crmul(offd2,-2.));
#endif
}
ctridiagonal_const_define (slv, diag2, offd2);
#ifdef SF_HAS_COMPLEX_H
trace[0] = diag*in[0] + offd*in[1];
#else
trace[0] = sf_cadd(sf_cmul(diag,in[0]),
sf_cmul(offd,in[1]));
#endif
for (k = 1; k < nx - 1; k++) {
#ifdef SF_HAS_COMPLEX_H
trace[k] = diag*in[k] + offd*(in[k+1]+in[k-1]);
#else
trace[k] = sf_cadd(sf_cmul(diag,in[k]),
sf_cmul(offd,sf_cadd(in[k+1],in[k-1])));
#endif
}
#ifdef SF_HAS_COMPLEX_H
trace[nx-1] = diag*in[nx-1] + offd*in[nx-2];
#else
trace[nx-1] = sf_cadd(sf_cmul(diag,in[nx-1]),
sf_cmul(offd,in[nx-2]));
#endif
ctridiagonal_solve (slv, trace);
}
int main(int argc, char* argv[])
{
bool verb,complx,sub,os;
int it,iz,im,ik,ix,i,j; /* index variables */
int nt,nz,nx, m2, nk, nzx, nz2, nx2, nzx2, n2, pad1,nth;
sf_complex c,old;
/* I/O arrays*/
sf_complex *ww,*curr,*prev,*cwave,*cwavem,**wave,**lt, **rt;
float *rcurr,*rr;
sf_file Fw,Fr,Fo; /* I/O files */
sf_axis at,az,ax; /* cube axes */
sf_file left, right;
sf_init(argc,argv);
if(!sf_getbool("verb",&verb)) verb=false; /* verbosity */
if(!sf_getbool("cmplx",&complx)) complx=true; /* outputs complex wavefield */
if(!sf_getbool("os",&os)) os=true; /* one-step flag */
if (os) {
sf_warning("One-step wave extrapolation");
if(!sf_getbool("sub",&sub)) sub=false; /* subtraction flag */
} else {
sf_warning("Two-step wave extrapolation");
if(!sf_getbool("sub",&sub)) sub=true; /* subtraction flag */
}
/* setup I/O files */
Fw = sf_input ("in" );
Fo = sf_output("out");
Fr = sf_input ("ref");
if (SF_COMPLEX != sf_gettype(Fw)) sf_error("Need complex input");
if (SF_FLOAT != sf_gettype(Fr)) sf_error("Need float ref");
if(complx)
sf_settype(Fo,SF_COMPLEX);
else
sf_settype(Fo,SF_FLOAT);
/* Read/Write axes */
at = sf_iaxa(Fw,1); nt = sf_n(at);
az = sf_iaxa(Fr,1); nz = sf_n(az);
ax = sf_iaxa(Fr,2); nx = sf_n(ax);
sf_oaxa(Fo,az,1);
sf_oaxa(Fo,ax,2);
sf_oaxa(Fo,at,3);
if (!sf_getint("pad1",&pad1)) pad1=1; /* padding factor on the first axis */
#ifdef _OPENMP
#pragma omp parallel
{
nth = omp_get_num_threads();
}
if (verb) sf_warning(">>>> Using %d threads <<<<<", nth);
#endif
nk = cfft2_init(pad1,nz,nx,&nz2,&nx2);
nzx = nz*nx;
nzx2 = nz2*nx2;
/* propagator matrices */
left = sf_input("left");
right = sf_input("right");
if (!sf_histint(left,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in left",nzx);
if (!sf_histint(left,"n2",&m2)) sf_error("Need n2= in left");
if (!sf_histint(right,"n1",&n2) || n2 != m2) sf_error("Need n1=%d in right",m2);
if (!sf_histint(right,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in right",nk);
lt = sf_complexalloc2(nzx,m2);
rt = sf_complexalloc2(m2,nk);
sf_complexread(lt[0],nzx*m2,left);
sf_complexread(rt[0],m2*nk,right);
sf_fileclose(left);
sf_fileclose(right);
/* read wavelet & reflectivity */
ww=sf_complexalloc(nt);
sf_complexread(ww,nt ,Fw);
rr=sf_floatalloc(nzx);
sf_floatread(rr,nzx,Fr);
curr = sf_complexalloc(nzx2);
if (!os) prev = sf_complexalloc(nzx2);
else prev = NULL;
if(!complx) rcurr = sf_floatalloc(nzx2);
else rcurr=NULL;
cwave = sf_complexalloc(nk);
cwavem = sf_complexalloc(nk);
wave = sf_complexalloc2(nzx2,m2);
icfft2_allocate(cwavem);
for (iz=0; iz < nzx2; iz++) {
curr[iz] = sf_cmplx(0.,0.);
if (!os) prev[iz] = sf_cmplx(0.,0.);
if(!complx) rcurr[iz]= 0.;
}
/* MAIN LOOP */
for (it=0; it<nt; it++) {
if(verb) sf_warning("it=%d;",it);
/* matrix multiplication */
cfft2(curr,cwave);
for (im = 0; im < m2; im++) {
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]); //complex multiplies complex
#endif
}
icfft2(wave[im],cwavem);
}
for (ix = 0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
i = iz+ix*nz; /* original grid */
j = iz+ix*nz2; /* padded grid */
#ifdef SF_HAS_COMPLEX_H
c = ww[it] * rr[i]; // source term
#else
c = sf_crmul(ww[it], rr[i]); // source term
#endif
if (sub) c += curr[j];
if (!os) {
old = curr[j];
#ifdef SF_HAS_COMPLEX_H
c += sub? (old-prev[j]) : -prev[j];
#else
c = sf_cadd(c,sub? sf_csub(old,prev[j]) : sf_cneg(prev[j]));
#endif
prev[j] = old;
}
for (im = 0; im < m2; 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 (!complx) rcurr[j] = crealf(c);
}
/* write wavefield to output */
if (complx)
sf_complexwrite(curr+ix*nz2,nz,Fo);
else
sf_floatwrite(rcurr+ix*nz2,nz,Fo);
}
}
if(verb) sf_warning(".");
cfft2_finalize();
exit (0);
}
int main(int argc, char* argv[])
{
bool verb;
int it,iz,im,ikz,ikx,iky,ix,iy,i,j,snap; /* index variables */
int nt,nz,nx,ny, m2, nk, nzx, nz2, nx2, ny2, nzx2, n2, pad1;
float dt;
sf_complex c;
float *rr; /* I/O arrays*/
sf_complex *cwave, *cwavem, *ww;
sf_complex **wave, *curr;
float *rcurr, *rcurr_all;
sf_file Fw,Fr,Fo; /* I/O files */
sf_axis at,az,ax,ay; /* cube axes */
sf_complex **lt, **rt;
sf_file left, right, snaps;
/*MPI related*/
int cpuid,numprocs;
int provided;
int n_local, o_local;
int ozx2;
float *sendbuf, *recvbuf;
int *rcounts, *displs;
MPI_Init_thread(&argc,&argv,MPI_THREAD_FUNNELED,&provided);
threads_ok = provided >= MPI_THREAD_FUNNELED;
sf_init(argc,argv);
MPI_Comm_rank(MPI_COMM_WORLD, &cpuid);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
if(!sf_getbool("verb",&verb)) verb=true; /* verbosity */
/* setup I/O files */
Fw = sf_input ("--input" );
Fo = sf_output("--output");
Fr = sf_input ("ref");
/* Read/Write axes */
at = sf_iaxa(Fw,1); nt = sf_n(at); dt = sf_d(at);
az = sf_iaxa(Fr,1); nz = sf_n(az);
ax = sf_iaxa(Fr,2); nx = sf_n(ax);
ay = sf_iaxa(Fr,3); ny = sf_n(ay);
if (!sf_getint("pad1",&pad1)) pad1=1; /* padding factor on the first axis */
if (!sf_getint("snap",&snap)) snap=0;
/* interval for snapshots */
if (cpuid==0) {
sf_oaxa(Fo,az,1);
sf_oaxa(Fo,ax,2);
sf_oaxa(Fo,ay,3);
sf_settype(Fo,SF_FLOAT);
if (snap > 0) {
snaps = sf_output("snaps");
/* (optional) snapshot file */
sf_oaxa(snaps,az,1);
sf_oaxa(snaps,ax,2);
sf_oaxa(snaps,ay,3);
sf_oaxa(snaps,at,4);
sf_settype(snaps,SF_FLOAT);
sf_putint(snaps,"n4",nt/snap);
sf_putfloat(snaps,"d4",dt*snap);
sf_putfloat(snaps,"o4",0.);
} else {
snaps = NULL;
}
}
//nk = cfft3_init(pad1,nz,nx,ny,&nz2,&nx2,&ny2);
//n_local = ny2;
//o_local = 0;
nk = mcfft3_init(pad1,nz,nx,ny,&nz2,&nx2,&ny2,&n_local,&o_local);
sf_warning("Cpuid=%d,n2=%d,n1=%d,n0=%d,local_n0=%d,local_0_start=%d",cpuid,nz2,nx2,ny2,n_local,o_local);
nzx = nz*nx*ny;
//nzx2 = nz2*nx2*ny2;
nzx2 = n_local*nz2*nx2;
ozx2 = o_local*nz2*nx2;
/* propagator matrices */
left = sf_input("left");
right = sf_input("right");
if (!sf_histint(left,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in left",nzx);
if (!sf_histint(left,"n2",&m2)) sf_error("Need n2=%d in left",m2);
if (!sf_histint(right,"n1",&n2) || n2 != m2) sf_error("Need n1=%d in right",m2);
if (!sf_histint(right,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in right",nk);
lt = sf_complexalloc2(nzx,m2);
rt = sf_complexalloc2(m2,nk);
sf_complexread(lt[0],nzx*m2,left);
sf_complexread(rt[0],m2*nk,right);
/* read wavelet & reflectivity */
ww=sf_complexalloc(nt); sf_complexread(ww,nt ,Fw);
rr=sf_floatalloc(nzx); sf_floatread(rr,nzx,Fr);
curr = sf_complexalloc(nzx2);
rcurr= sf_floatalloc(nzx2);
cwave = sf_complexalloc(nzx2);
cwavem = sf_complexalloc(nzx2);
wave = sf_complexalloc2(nzx2,m2);
//icfft3_allocate(cwavem);
for (iz=0; iz < nzx2; iz++) {
curr[iz]=sf_cmplx(0.,0.);
rcurr[iz]=0.;
}
sendbuf = rcurr;
if (cpuid==0) {
rcurr_all = sf_floatalloc(nz2*nx2*ny2);
recvbuf = rcurr_all;
rcounts = sf_intalloc(numprocs);
displs = sf_intalloc(numprocs);
} else {
rcurr_all = NULL;
recvbuf = NULL;
rcounts = NULL;
displs = NULL;
}
MPI_Gather(&nzx2, 1, MPI_INT, rcounts, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Gather(&ozx2, 1, MPI_INT, displs, 1, MPI_INT, 0, MPI_COMM_WORLD);
/* MAIN LOOP */
for (it=0; it<nt; it++) {
if(verb) sf_warning("it=%d;",it);
/* matrix multiplication */
mcfft3(curr,cwave);
for (im = 0; im < m2; im++) {
for (iky = 0; iky < n_local; iky++) {
for (ikx = 0; ikx < nx2; ikx++) {
for (ikz = 0; ikz < nz2; ikz++) {
i = ikz + ikx*nz2 + (o_local+iky)*nx2*nz2;
j = ikz + ikx*nz2 + iky*nx2*nz2;
#ifdef SF_HAS_COMPLEX_H
cwavem[j] = cwave[j]*rt[i][im];
#else
cwavem[j] = sf_cmul(cwave[j],rt[i][im]);
#endif
}
}
}
imcfft3(wave[im],cwavem);
}
for (iy = 0; iy < n_local && (iy+o_local)<ny; iy++) {
for (ix = 0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
i = iz + ix*nz + (o_local+iy)*nx*nz; /* original grid */
j = iz + ix*nz2+ iy*nx2*nz2; /* padded grid */
#ifdef SF_HAS_COMPLEX_H
c = ww[it] * rr[i];
#else
c = sf_crmul(ww[it],rr[i]);
#endif
for (im = 0; im < m2; 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;
rcurr[j]= crealf(c);
}
}
}
/* output movie */
if (NULL != snaps && 0 == it%snap) {
MPI_Gatherv(sendbuf, nzx2, MPI_FLOAT, recvbuf, rcounts, displs, MPI_FLOAT, 0, MPI_COMM_WORLD);
if (cpuid==0) {
for (iy = 0; iy < ny; iy++)
for (ix = 0; ix < nx; ix++)
sf_floatwrite(rcurr_all+nz2*(ix+nx2*iy),nz,snaps);
}
}
}
if(verb) sf_warning(".");
/* write wavefield to output */
MPI_Gatherv(sendbuf, nzx2, MPI_FLOAT, recvbuf, rcounts, displs, MPI_FLOAT, 0, MPI_COMM_WORLD);
if (cpuid==0) {
for (iy = 0; iy < ny; iy++)
for (ix = 0; ix < nx; ix++)
sf_floatwrite(rcurr_all+nz2*(ix+nx2*iy),nz,Fo);
}
mcfft3_finalize();
MPI_Finalize();
exit (0);
}
int main(int argc, char* argv[])
{
/* Frequency axis = axis 1 of input, output */
int nw, iw;
float dw;
/* Axis 2 of input */
int nx, ix;
float ox, dx, x;
float p;
float *wp = NULL;
sf_complex *tr = NULL;
sf_file in, out;
/**********************************************************************/
/* Read parameters of input file */
sf_init (argc,argv);
in = sf_input ("in" );
out = sf_output("out");
if (SF_COMPLEX != sf_gettype(in)) sf_error("Need complex input");
if(!sf_histint (in,"n1",&nw)) sf_error ("No n1= in input");
if(!sf_histfloat(in,"d1",&dw)) sf_error ("No d1= in input");
if(!sf_histint (in,"n2",&nx)) sf_error ("No n2= in input");
if(!sf_histfloat(in,"o2",&ox)) sf_error ("No o2= in input");
if(!sf_histfloat(in,"d2",&dx)) sf_error ("No d2= in input");
/* Read parameters from the command line */
if (!sf_getfloat("p", &p)) sf_error("Need p=");
/* Slope of LMO */
/* The frequency axis */
wp = sf_floatalloc( nw );
for (iw=0; iw < nw; iw++) {
wp[iw] = p * iw * dw * 2*SF_PI;
}
tr = sf_complexalloc( nw );
for (ix=0; ix < nx; ix++) {
x = ox + ix * dx;
sf_complexread ( tr, nw, in ); /* Read the gather */
for (iw=1; iw < nw; iw++) {
#ifdef SF_HAS_COMPLEX_H
tr[iw] *= cexpf(sf_cmplx(0.,-wp[iw] * x ));
#else
tr[iw] = sf_cmul(tr[iw],cexpf(sf_cmplx(0.,-wp[iw] * x )));
#endif
}
sf_complexwrite( tr, nw , out );
}
}
int main (int argc, char* argv[])
{
int n1, n2, n, nk, i, j, k, nlags;
float *data, wt;
sf_complex **fft, *dataf;
sf_file inp, out;
#ifdef SF_HAS_FFTW
fftwf_plan cfg=NULL, icfg=NULL;
#else
kiss_fftr_cfg cfg=NULL, icfg=NULL;
#endif
sf_init(argc, argv);
inp = sf_input("in");
out = sf_output("out");
if (SF_FLOAT != sf_gettype(inp)) sf_error("Need float input");
if (!sf_histint(inp,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(inp,"n2",&n2)) sf_error("No n2= in input");
if (!sf_getint("nlags",&nlags)) nlags=100; /* number of lags */
sf_putint(out,"n1",nlags);
sf_putint(out,"n3",n2);
nk = kiss_fft_next_fast_size((n1+1)/2)+1;
n = 2*(nk-1);
wt = 1.0/n;
data = sf_floatalloc(n);
dataf = sf_complexalloc(nk);
fft = sf_complexalloc2(nk,n2);
#ifdef SF_HAS_FFTW
cfg = fftwf_plan_dft_r2c_1d(n, data, (fftwf_complex *) dataf,
FFTW_MEASURE);
icfg = fftwf_plan_dft_c2r_1d(n, (fftwf_complex *) dataf, data,
FFTW_MEASURE);
if (NULL == cfg || NULL == icfg) sf_error("FFT allocation failure");
#else
cfg = kiss_fftr_alloc(n,0,NULL,NULL);
icfg = kiss_fftr_alloc(n,1,NULL,NULL);
#endif
for (i=0; i < n2; i++) {
sf_floatread(data,n1,inp);
for (k=n1; k < n; k++) {
data[k] = 0.0f;
}
#ifdef SF_HAS_FFTW
fftwf_execute(cfg);
#else
kiss_fftr (cfg,data,(kiss_fft_cpx *) dataf);
#endif
for (k=0; k < nk; k++) {
fft[i][k] = dataf[k];
}
}
/*************************************************
* *
* cross-correlate every trace with every other *
* *
*************************************************/
for (i=0; i < n2; i++) {
for (j=0; j < n2; j++) {
for (k=0; k < nk; k++) {
#ifdef SF_HAS_COMPLEX_H
dataf[k] = fft[i][k] * conjf(fft[j][k]);
#else
dataf[k] = sf_cmul(fft[i][k],conjf(fft[j][k]));
#endif
}
#ifdef SF_HAS_FFTW
fftwf_execute(icfg);
#else
kiss_fftri(icfg,(kiss_fft_cpx *) dataf,data);
#endif
for (k=0; k < nlags; k++) {
data[k] *= wt;
}
sf_floatwrite(data,nlags,out);
}
}
exit(0);
}
int main(int argc, char* argv[])
{
/*define variables*/
int nx,nx1,nt;
int n1,n2;
float d1,o1,d2,o2;
int padt,padx;
int ntfft,*n,nw,nk;
float **d,*wavelet,**shot,**ds,**vel,**vmig,**M,v_ave;
float *kx,*omega,dkx,dw;
sf_complex **m,**ms,**mr,*in2a,*in2b,*cs,*cr,*c,czero;
sf_complex Ls;
float fmin,fmax,f_low,f_high;
int if_low,if_high;
int ix,iw,ik;
float dt,dx,ox,dz,zmax;
fftwf_plan p2a,p2b;
sf_file in,out,velfile,source_wavelet;
int iz,nz;
int ishot,max_num_shot,ig,ng,it,index;
int iswavelet;
/*define sf input output*/
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
velfile = sf_input("velfile");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input");
if (!sf_histfloat(in,"o1",&o1)) o1=0.;
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in vel");
if (!sf_histfloat(in,"d2",&d2)) sf_error("No d2= in input");
if (!sf_histfloat(in,"o2",&o2)) o2=0.;
dt = d1;
dx = d2;
ox = o2;
nx1 = n2;
nt = n1;
if (!sf_histint(velfile,"n1",&nz)) sf_error("No n1= in vel");
if (!sf_histfloat(velfile,"d1",&dz)) sf_error("No n1= in vel");
if (!sf_histint(velfile,"n2",&n2)) sf_error("No n2= in vel");
if (!sf_getint("iswavelet",&iswavelet)) iswavelet = 0;
source_wavelet=sf_input("source_wavelet");
max_num_shot=100;
ng=700;
nx=n2;
padt = 2;
padx = 2;
ntfft = padt*nt;
nw=ntfft/2+1;
nk = padx*nx;
dw = 2*PI/ntfft/dt;
dkx = 2*PI/nk/dx;
sf_putint(out,"n1",nz);
sf_putint(out,"n2",nx);
sf_putfloat(out,"d1",dz);
sf_putstring(out,"label1","z");
sf_putstring(out,"unit1","m");
sf_putstring(out,"title","migrated");
if (!sf_getfloat("fmax",&fmax)) fmax = 0.5/d1; /* max frequency to process */
if (fmax > 0.5/d1) fmax = 0.5/d1;
if (!sf_getfloat("fmin",&fmin)) fmin = 0.1; /* min frequency to process */
if (!sf_getfloat("Zmax",&zmax)) zmax = (nz-1)*dz; /* max Depth to migrate */
/*define axis variables*/
dkx=(float) 2*PI/nk/dx;
dw=(float) 2*PI/ntfft/dt;
/*allocate memory to dynamic arrays*/
d = sf_floatalloc2(nt,nx1);
shot=sf_floatalloc2(nt,ng);
ds=sf_floatalloc2(nt,nx);
vel = sf_floatalloc2(nz,nx);
wavelet=sf_floatalloc(nt);
vmig = sf_floatalloc2(nz,nx);
m = sf_complexalloc2(nw,nx);
ms = sf_complexalloc2(nw,nx);
mr = sf_complexalloc2(nw,nx);
kx= sf_floatalloc (nk);
omega= sf_floatalloc (nw);
in2a = sf_complexalloc(nk);
in2b = sf_complexalloc(nk);
n = sf_intalloc(1);
M= sf_floatalloc2(nz,nx);
c = sf_complexalloc(nx);
cs = sf_complexalloc(nx);
cr = sf_complexalloc(nx);
/*read input files*/
sf_floatread(d[0],nx1*nt,in);
sf_floatread(vel[0],nx*nz,velfile);
/* If there is no wavelet use delta as default
If there is a wavelet use it*/
if (iswavelet==0) {
for (it=0; it<nt; it++) wavelet[it] = 0.0;
wavelet[0]=1;
}
if (iswavelet==1) sf_floatread(wavelet,nt,source_wavelet);
/* This part is important: we need to define the horizontal wavenumber and frequency axes right.*/
dw = 2*PI/ntfft/dt;
dkx = 2*PI/nk/dx;
for (iw=0;iw<nw;iw++){
omega[iw] = dw*iw;
}
for (ik=0;ik<nk;ik++){
if (ik<nk/2) kx[ik] = dkx*ik;
else kx[ik] = -(dkx*nk - dkx*ik);
}
/* Define minimum and maximum frequency index to process*/
f_low = fmin; /* min frequency to process */
f_high = fmax; /* max frequency to process */
if(f_low>0){
if_low = trunc(f_low*dt*ntfft);
}
else{
if_low = 0;
}
if(f_high*dt*ntfft+1<nw){
if_high = trunc(f_high*dt*ntfft)+1;
}
else{
if_high = nw;
}
__real__ czero = 0;
__imag__ czero = 0;
n[0] = nk;
p2a = fftwf_plan_dft(1, n, (fftwf_complex*)in2a, (fftwf_complex*)in2a, FFTW_FORWARD, FFTW_ESTIMATE);
p2b = fftwf_plan_dft(1, n, (fftwf_complex*)in2b, (fftwf_complex*)in2b, FFTW_BACKWARD, FFTW_ESTIMATE);
fftwf_execute(p2a); /* FFT x to k */
fftwf_execute(p2b); /* FFT x to k */
/* Define initial migrated model and source field as zeros*/
for (iz=0; iz<nz; iz++) {
for (ix=0; ix<nx; ix++) M[ix][iz] = 0.0;
}
for (it=0; it<nt; it++) {
for (ix=0; ix<nx; ix++) ds[ix][it] = 0.0;
}
for (iz=0; iz<nz;iz++){
for (ix=0;ix<nx;ix++) vmig[ix][iz]=vel[ix][iz];
}
/* loop over shots*/
for (ishot=0;ishot<max_num_shot;ishot++){
for (ig=0;ig<ng;ig++){
for (it=0; it<nt; it++)
shot[ig][it]=d[ishot*ng+ig][it];
}
for (it=0; it<nt; it++) {
for (ix=0; ix<nx; ix++) ds[ix][it] = 0.0;
}
index=ishot*nx/max_num_shot;
for (it=0; it<nt; it++) ds[index][it]=wavelet[it];
/* apply fourier transform in time direction t-x ---> w-x*/
my_forward_fft(ms,mr,shot,ds,nt,dt,nx,padt);
for (iw=if_low;iw<if_high;iw++){
for (iz=0; iz<nz;iz++){
v_ave=vmig[0][iz];
my_v_ave (v_ave,vmig,iz,nx);
/*Apply phase shift to source side*/
my_phase_shift(ms,czero,iw,iz,omega,kx,nk,nx,v_ave,in2a,in2b,p2a,p2b,dz,0);
for (ix=0;ix<nx;ix++) {
cs[ix]= in2b[ix];
}
/*Apply phase shift to receiver side*/
my_phase_shift(mr,czero,iw,iz,omega,kx,nk,nx,v_ave,in2a,in2b,p2a,p2b,dz,1);
for (ix=0;ix<nx;ix++) {
cr[ix]= in2b[ix];
}
/*Apply split step correction to source and receiver side wavefields*/
my_split_step_correction (ms,cs,vmig,v_ave,iz,dz,iw,dw,nx,0);
my_split_step_correction (mr,cr,vmig,v_ave,iz,dz,iw,dw,nx,1);
/* Apply cross corrolation as an imaging condition*/
for (ix=0;ix<nx;ix++){
__real__ Ls=crealf(ms[ix][iw]);
__imag__ Ls=- cimagf(ms[ix][iw]);
m[ix][iw]=mr[ix][iw]*Ls;
}
/* Update migrated model by stacking*/
for (ix=0;ix<nx;ix++) M[ix][iz]=M[ix][iz]+2*crealf(m[ix][iw]);
}
}
fprintf(stderr,"\r progress = %6.2f%%",(float) 100*(ishot)/(max_num_shot));
}
sf_floatwrite(M[0],nz*nx,out);
fftwf_destroy_plan(p2a);
fftwf_free(in2a);
fftwf_destroy_plan(p2b);
fftwf_free(in2b);
exit (0);
}
/* main function */
int main(int argc, char* argv[])
{
clock_t tstart,tend;
double duration;
/*flags*/
bool verb, adj; /* migration(adjoint) flag */
bool wantwf; /* outputs wavefield snapshots */
bool wantrecord; /* actually means "need record" */
bool illum; /* source illumination flag*/
bool roll; /* survey strategy */
/*I/O*/
sf_file Fvel;
sf_file left, right, leftb, rightb;
sf_file Fsrc, Frcd/*source and record*/;
sf_file Ftmpwf;
sf_file Fimg;
/*axis*/
sf_axis at, ax, az, as;
/*grid index variables*/
int nx, nz, nt, wfnt;
int nzx, nx2, nz2, n2, m2, m2b, pad1, nk;
int ix, iz, it, is;
int nxb, nzb;
int snpint;
float dt, dx, dz, wfdt;
float ox, oz;
/*source/geophone location*/
int spx, spz;
int gpz,gpx,gpl; /*geophone depth/x-crd/length*/
/*Model*/
sf_complex **lt, **rt;
sf_complex **ltb, **rtb;
/*Data*/
sf_complex ***wavefld;
sf_complex ***record, **tmprec, **img, **imgsum;
float **sill;
/*source*/
sf_complex *ww;
float *rr;
int rectz,rectx,repeat; /*smoothing parameters*/
float trunc;
int sht0,shtbgn,shtend,shtnum,shtnum0,shtint,shtcur;
/*abc boundary*/
int top,bot,lft,rht;
/*tmp*/
int tmpint;
/*parameter structs*/
geopar geop;
mpipar mpip;
/*MPI*/
int rank, nodes;
sf_complex *sendbuf, *recvbuf;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nodes);
sf_init(argc, argv);
if(rank==0) sf_warning("nodes=%d",nodes);
if (!sf_getbool("verb", &verb)) verb=false; /*verbosity*/
if (!sf_getbool("adj", &adj)) adj=true; /*migration*/
if (!sf_getbool("wantwf", &wantwf)) wantwf=false; /*output forward and backward wavefield*/
if (!sf_getbool("wantrecord", &wantrecord)) wantrecord=true; /*if n, using record data generated by this program */
if (!sf_getbool("illum", &illum)) illum=false; /*if n, no source illumination applied */
if (!sf_getbool("roll", &roll)) roll=false; /*if n, receiver is independent of source location and gpl=nx*/
/* source/receiver info */
if (!sf_getint("shtbgn", &shtbgn)) sf_error("Need shot starting location on grid!");
if (!sf_getint("sht0", &sht0)) sht0=shtbgn; /*actual shot origin on grid*/
if (!sf_getint("shtend", &shtend)) sf_error("Need shot ending location on grid!");
if (!sf_getint("shtint", &shtint)) sf_error("Need shot interval on grid!");
shtnum = (int)((shtend-shtbgn)/shtint) + 1;
shtnum0 = shtnum;
if (!sf_getint("spz", &spz)) sf_error("Need source depth!");
if (!sf_getint("gpz", &gpz)) sf_error("Need receiver depth!");
if (roll) if (!sf_getint("gpl", &gpl)) sf_error("Need receiver length");
if (!sf_getint("snapinter", &snpint)) snpint=1; /* snap interval */
/*--- parameters of source ---*/
if (!sf_getfloat("srctrunc", &trunc)) trunc=0.4;
if (!sf_getint("rectz", &rectz)) rectz=1;
if (!sf_getint("rectx", &rectx)) rectx=1;
if (!sf_getint("repeat", &repeat)) repeat=0;
/* abc parameters */
if (!sf_getint("top", &top)) top=40;
if (!sf_getint("bot", &bot)) bot=40;
if (!sf_getint("lft", &lft)) lft=40;
if (!sf_getint("rht", &rht)) rht=40;
/*Set I/O file*/
if (adj) { /* migration */
if (wantrecord) {
Frcd = sf_input("input"); /*record from elsewhere*/
Fsrc = sf_input("src"); /*source wavelet*/
} else {
Frcd = sf_output("rec"); /*record produced by forward modeling*/
Fsrc = sf_input("input"); /*source wavelet*/
}
Fimg = sf_output("output");
} else { /* modeling */
Fimg = sf_input("input");
Frcd = sf_output("output");
Fsrc = sf_input("src"); /*source wavelet*/
}
left = sf_input("left");
right = sf_input("right");
leftb = sf_input("leftb");
rightb = sf_input("rightb");
Fvel = sf_input("vel"); /*velocity - just for model dimension*/
if (wantwf) {
Ftmpwf = sf_output("tmpwf");/*wavefield snap*/
} else {
Ftmpwf = NULL;
}
/*--- Axes parameters ---*/
at = sf_iaxa(Fsrc, 1); nt = sf_n(at); dt = sf_d(at);
az = sf_iaxa(Fvel, 1); nzb = sf_n(az); dz = sf_d(az); oz = sf_o(az);
ax = sf_iaxa(Fvel, 2); nxb = sf_n(ax); dx = sf_d(ax); ox = sf_o(ax);
nzx = nzb*nxb;
nz = nzb - top - bot;
nx = nxb - lft - rht;
if (!roll) gpl = nx; /* global survey setting */
/* wavefield axis */
wfnt = (int)(nt-1)/snpint+1;
wfdt = dt*snpint;
/* propagator matrices */
if (!sf_getint("pad1",&pad1)) pad1=1; /* padding factor on the first axis */
nz2 = kiss_fft_next_fast_size(nzb*pad1);
nx2 = kiss_fft_next_fast_size(nxb);
nk = nz2*nx2; /*wavenumber*/
if (!sf_histint(left,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in left",nzx);
if (!sf_histint(left,"n2",&m2)) sf_error("Need n2= in left");
if (!sf_histint(right,"n1",&n2) || n2 != m2) sf_error("Need n1=%d in right",m2);
if (!sf_histint(right,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in right",nk);
if (!sf_histint(leftb,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in left",nzx);
if (!sf_histint(leftb,"n2",&m2b)) sf_error("Need n2= in left");
if (!sf_histint(rightb,"n1",&n2) || n2 != m2b) sf_error("Need n1=%d in right",m2b);
if (!sf_histint(rightb,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in right",nk);
/*check record data*/
if (adj && wantrecord){
sf_histint(Frcd,"n1", &tmpint);
if (tmpint != nt ) sf_error("Error parameter n1 in record!");
sf_histint(Frcd,"n2", &tmpint);
if (tmpint != gpl ) sf_error("Error parameter n2 in record!");
sf_histint(Frcd,"n3", &tmpint);
if (tmpint != shtnum0 ) sf_error("Error parameter n3 in record!");
}
/*allocate memory*/
ww=sf_complexalloc(nt);
rr=sf_floatalloc(nzx);
lt = sf_complexalloc2(nzx,m2);
rt = sf_complexalloc2(m2,nk);
ltb = sf_complexalloc2(nzx,m2b);
rtb = sf_complexalloc2(m2b,nk);
geop = (geopar) sf_alloc(1, sizeof(*geop));
mpip = (mpipar) sf_alloc(1, sizeof(*mpip));
tmprec = sf_complexalloc2(nt, gpl);
if (shtnum%nodes!=0) {
shtnum += nodes-shtnum%nodes;
if (verb) sf_warning("Total shot number is not divisible by total number of nodes! shunum padded to %d.", shtnum);
}
if (rank==0) {
record = sf_complexalloc3(nt, gpl, shtnum);
} else record = NULL;
wavefld = sf_complexalloc3(nz, nx, wfnt);
if (illum) sill = sf_floatalloc2(nz, nx);
else sill = NULL;
img = sf_complexalloc2(nz, nx);
if (adj) {
imgsum = sf_complexalloc2(nz, nx);
#ifdef _OPENMP
#pragma omp parallel for private(ix,iz)
#endif
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
imgsum[ix][iz] = sf_cmplx(0.,0.);
}
/*read from files*/
sf_complexread(ww,nt,Fsrc);
sf_complexread(lt[0],nzx*m2,left);
sf_complexread(rt[0],m2*nk,right);
sf_complexread(ltb[0],nzx*m2b,leftb);
sf_complexread(rtb[0],m2b*nk,rightb);
if(!adj) sf_complexread(img[0],nx*nz,Fimg);
if (rank==0) {
if(adj && wantrecord) {
sf_complexread(record[0][0], shtnum0*gpl*nt, Frcd);
if (shtnum0%nodes!=0) {
#ifdef _OPENMP
#pragma omp parallel for private(is,ix,it)
#endif
for (is=shtnum0; is<shtnum; is++)
for (ix=0; ix<gpl; ix++)
for (it=0; it<nt; it++)
record[is][ix][it] = sf_cmplx(0.,0.);
}
} else {
#ifdef _OPENMP
#pragma omp parallel for private(is,ix,it)
#endif
for (is=0; is<shtnum; is++)
for (ix=0; ix<gpl; ix++)
for (it=0; it<nt; it++)
record[is][ix][it] = sf_cmplx(0.,0.);
}
}
/*close RSF files*/
sf_fileclose(Fsrc);
sf_fileclose(left);
sf_fileclose(right);
sf_fileclose(leftb);
sf_fileclose(rightb);
/*load constant geopar elements*/
mpip->cpuid=rank;
mpip->numprocs=nodes;
/*load constant geopar elements*/
geop->nx = nx;
geop->nz = nz;
geop->nxb = nxb;
geop->nzb = nzb;
geop->dx = dx;
geop->dz = dz;
geop->ox = ox;
geop->oz = oz;
geop->snpint = snpint;
geop->spz = spz;
geop->gpz = gpz;
geop->gpl = gpl;
geop->top = top;
geop->bot = bot;
geop->lft = lft;
geop->rht = rht;
geop->nt = nt;
geop->dt = dt;
geop->trunc = trunc;
geop->shtnum = shtnum;
/* output RSF files */
if (rank==0) {
sf_setn(ax, gpl);
sf_setn(az, nz);
as = sf_iaxa(Fvel, 2);
sf_setn(as,shtnum0);
sf_setd(as,shtint*dx);
sf_seto(as,shtbgn*dx+ox);
if (adj) { /* migration */
if(!wantrecord) {
sf_oaxa(Frcd, at, 1);
sf_oaxa(Frcd, ax, 2);
sf_oaxa(Frcd, as, 3);
sf_settype(Frcd,SF_COMPLEX);
}
sf_setn(ax, nx);
/*write image*/
sf_oaxa(Fimg, az, 1);
sf_oaxa(Fimg, ax, 2);
sf_settype(Fimg,SF_COMPLEX);
} else { /* modeling */
sf_oaxa(Frcd, at, 1);
sf_oaxa(Frcd, ax, 2);
sf_oaxa(Frcd, as ,3);
sf_settype(Frcd,SF_COMPLEX);
}
if (wantwf) {
sf_setn(ax, nx);
/*write temp wavefield */
sf_setn(at, wfnt);
sf_setd(at, wfdt);
sf_oaxa(Ftmpwf, az, 1);
sf_oaxa(Ftmpwf, ax, 2);
sf_oaxa(Ftmpwf, at, 3);
sf_settype(Ftmpwf,SF_COMPLEX);
}
}
tstart = clock();
for (is=0; is*nodes<shtnum; is++){
shtcur = is*nodes+rank; // current shot index
if (shtcur<shtnum0) {
spx = shtbgn + shtint*(shtcur);
if (roll)
gpx = spx - (int)(gpl/2);
else
gpx = 0;
geop->spx = spx;
geop->gpx = gpx;
if (verb) {
sf_warning("============================");
sf_warning("processing shot #%d", shtcur);
sf_warning("nx=%d nz=%d nt=%d", geop->nx, geop->nz, geop->nt);
sf_warning("nxb=%d nzb=%d ", geop->nxb, geop->nzb);
sf_warning("dx=%f dz=%f dt=%f", geop->dx, geop->dz, geop->dt);
sf_warning("top=%d bot=%d lft=%d rht=%d", geop->top, geop->bot, geop->lft, geop->rht);
sf_warning("rectz=%d rectx=%d repeat=%d srctrunc=%f",rectz,rectx,repeat,geop->trunc);
sf_warning("spz=%d spx=%d gpz=%d gpx=%d gpl=%d", spz, spx, gpz, gpx, gpl);
sf_warning("snpint=%d wfdt=%f wfnt=%d ", snpint, wfdt, wfnt);
sf_warning("sht0=%d shtbgn=%d shtend=%d shtnum0=%d shtnum=%d", sht0, shtbgn, shtend, shtnum0, shtnum);
if (roll) sf_warning("Rolling survey!");
else sf_warning("Global survey (gpl=nx)!");
if (illum) sf_warning("Using source illumination!");
else sf_warning("No source illumination!");
sf_warning("============================");
}
/*generate reflectivity map*/
reflgen(nzb, nxb, spz+top, spx+lft, rectz, rectx, repeat, rr);
lrosfor2(wavefld, sill, tmprec, verb, lt, rt, m2, geop, ww, rr, pad1, illum);
}
if(adj && wantrecord) {
if (rank==0) sendbuf = record[is*nodes][0];
else sendbuf = NULL;
recvbuf = tmprec[0];
MPI_Scatter(sendbuf, gpl*nt, MPI_COMPLEX, recvbuf, gpl*nt, MPI_COMPLEX, 0, MPI_COMM_WORLD); // tmprec[ix][it] = record[is][ix][it];
}
if (shtcur<shtnum0) {
lrosback2(img, wavefld, sill, tmprec, adj, verb, wantwf, ltb, rtb, m2b, geop, pad1, illum);
if (adj) { /*local image reduction*/
#ifdef _OPENMP
#pragma omp parallel for private(ix,iz)
#endif
for (ix=0; ix<nx; ix++) {
for (iz=0; iz<nz; iz++) {
#ifdef SF_HAS_COMPLEX_H
imgsum[ix][iz] += img[ix][iz];
#else
imgsum[ix][iz] = sf_cadd(imgsum[ix][iz],img[ix][iz]);
#endif
}
}
}
}
if (!adj || !wantrecord) {
// MPI_Barrier(MPI_COMM_WORLD);
if (rank==0) recvbuf = record[is*nodes][0];
else recvbuf = NULL;
sendbuf = tmprec[0];
MPI_Gather(sendbuf, gpl*nt, MPI_COMPLEX, recvbuf, gpl*nt, MPI_COMPLEX, 0, MPI_COMM_WORLD); // record[is][ix][it] = tmprec[ix][it];
}
if (wantwf && shtcur==0)
sf_complexwrite(wavefld[0][0], wfnt*nx*nz, Ftmpwf);
} /*shot iteration*/
MPI_Barrier(MPI_COMM_WORLD);
/*write record/image*/
if (adj) {
if (rank==0) {
#if MPI_VERSION >= 2
sendbuf = (sf_complex *) MPI_IN_PLACE;
#else /* will fail */
sendbuf = NULL;
#endif
recvbuf = imgsum[0];
} else {
sendbuf = imgsum[0];
recvbuf = NULL;
}
MPI_Reduce(sendbuf, recvbuf, nx*nz, MPI_COMPLEX, MPI_SUM, 0, MPI_COMM_WORLD);
if (rank==0)
sf_complexwrite(imgsum[0], nx*nz, Fimg);
}
if (!adj || !wantrecord) {
if (rank==0)
sf_complexwrite(record[0][0], shtnum0*gpl*nt, Frcd);
}
/*free memory*/
free(ww); free(rr);
free(*lt); free(lt);
free(*rt); free(rt);
free(*ltb);free(ltb);
free(*rtb);free(rtb);
free(geop);free(mpip);
free(*tmprec); free(tmprec);
if (rank==0) {free(**record); free(*record); free(record);}
free(**wavefld); free(*wavefld); free(wavefld);
if (illum) {
free(*sill); free(sill);
}
free(*img); free(img);
if (adj) {
free(*imgsum); free(imgsum);
}
tend = clock();
duration=(double)(tend-tstart)/CLOCKS_PER_SEC;
sf_warning(">> The CPU time of single shot migration is: %f seconds << ", duration);
MPI_Finalize();
exit(0);
}
int main(int argc, char* argv[])
{
bool mig,timer;
int it, nt, ix, nx, iz, nz, nx2, nz2, nzx, nzx2, pad1;
int im, i, j, m2, it1, it2, its, ik, n2, nk;
float dt, dx, dz,x0;
sf_complex *curr, **img, *dat, **lft, **rht, **wave, *cwave, *cwavem, c;
sf_file data, image, left, right;
double time=0.,t0=0.,t1=0.;
sf_init(argc,argv);
if (!sf_getbool("mig",&mig)) mig=false;
/* if n, modeling; if y, migration */
if(! sf_getbool("timer",&timer)) timer=false;
if (!sf_getint("pad1",&pad1)) pad1=1; /* padding factor on the first axis */
if (mig) { /* migration */
data = sf_input("in");
image = sf_output("out");
sf_settype(image,SF_COMPLEX);
if (!sf_histint(data,"n1",&nx)) sf_error("No n1= in input");
if (!sf_histfloat(data,"d1",&dx)) sf_error("No d1= in input");
if (!sf_histfloat(data,"o1",&x0)) x0=0.;
if (!sf_histint(data,"n2",&nt)) sf_error("No n2= in input");
if (!sf_histfloat(data,"d2",&dt)) sf_error("No d2= in input");
if (!sf_getint("nz",&nz)) sf_error("Need nz=");
/* depth samples (if migration) */
if (!sf_getfloat("dz",&dz)) sf_error("Need dz=");
/* depth sampling (if migration) */
sf_putint(image,"n1",nz);
sf_putfloat(image,"d1",dz);
sf_putfloat(image,"o1",0.);
sf_putstring(image,"label1","Depth");
sf_putint(image,"n2",nx);
sf_putfloat(image,"d2",dx);
sf_putfloat(image,"o2",x0);
sf_putstring(image,"label2","Distance");
} else { /* modeling */
image = sf_input("in");
data = sf_output("out");
sf_settype(data,SF_COMPLEX);
if (!sf_histint(image,"n1",&nz)) sf_error("No n1= in input");
if (!sf_histfloat(image,"d1",&dz)) sf_error("No d1= in input");
if (!sf_histint(image,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histfloat(image,"d2",&dx)) sf_error("No d2= in input");
if (!sf_histfloat(image,"o2",&x0)) x0=0.;
if (!sf_getint("nt",&nt)) sf_error("Need nt=");
/* time samples (if modeling) */
if (!sf_getfloat("dt",&dt)) sf_error("Need dt=");
/* time sampling (if modeling) */
sf_putint(data,"n1",nx);
sf_putfloat(data,"d1",dx);
sf_putfloat(data,"o1",x0);
sf_putstring(data,"label1","Distance");
sf_putint(data,"n2",nt);
sf_putfloat(data,"d2",dt);
sf_putfloat(data,"o2",0.);
sf_putstring(data,"label2","Time");
sf_putstring(data,"unit2","s");
}
nk = cfft2_init(pad1,nx,nz,&nx2,&nz2);
nzx = nz*nx;
nzx2 = nz2*nx2;
img = sf_complexalloc2(nz,nx);
dat = sf_complexalloc(nx);
/* propagator matrices */
left = sf_input("left");
right = sf_input("right");
if (!sf_histint(left,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in left",nzx);
if (!sf_histint(left,"n2",&m2)) sf_error("No n2= in left");
if (!sf_histint(right,"n1",&n2) || n2 != m2) sf_error("Need n1=%d in right",m2);
if (!sf_histint(right,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in right",nk);
lft = sf_complexalloc2(nzx,m2);
rht = sf_complexalloc2(m2,nk);
sf_complexread(lft[0],nzx*m2,left);
sf_complexread(rht[0],m2*nk,right);
curr = sf_complexalloc(nzx2);
cwave = sf_complexalloc(nk);
cwavem = sf_complexalloc(nk);
wave = sf_complexalloc2(nzx2,m2);
icfft2_allocate(cwavem);
for (iz=0; iz < nzx2; iz++) {
curr[iz] = sf_cmplx(0.,0.);
}
if (mig) { /* migration */
/* step backward in time */
it1 = nt-1;
it2 = -1;
its = -1;
} else { /* modeling */
sf_complexread(img[0],nzx,image);
/* transpose */
for (ix=0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
curr[ix+iz*nx2]=img[ix][iz];
}
}
/* step forward in time */
it1 = 0;
it2 = nt;
its = +1;
}
if (timer) t0 = gtod_timer();
/* time stepping */
for (it=it1; it != it2; it += its) {
sf_warning("it=%d;",it);
if (mig) { /* migration <- read data */
sf_complexread(dat,nx,data);
} else {
for (ix=0; ix < nx; ix++) {
dat[ix] = sf_cmplx(0.,0.);
}
}
for (ix=0; ix < nx; ix++) {
if (mig) {
#ifdef SF_HAS_COMPLEX_H
curr[ix] += dat[ix];
#else
curr[ix] = sf_cadd(curr[ix],dat[ix]);
#endif
} else {
dat[ix] = curr[ix];
}
}
/* matrix multiplication */
cfft2(curr,cwave);
for (im = 0; im < m2; im++) {
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*rht[ik][im];
#else
cwavem[ik] = sf_cmul(cwave[ik],rht[ik][im]);
#endif
}
icfft2(wave[im],cwavem);
}
#ifdef _OPENMP
#pragma omp parallel for private(ix,iz,i,j,im,c) shared(curr,lft,wave)
#endif
for (ix = 0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
i = ix+iz*nx; /* original grid */
j = ix+iz*nx2; /* padded grid */
c = sf_cmplx(0.,0.); /* initialize */
for (im = 0; im < m2; im++) {
#ifdef SF_HAS_COMPLEX_H
c += lft[im][i]*wave[im][j];
#else
c = sf_cadd(c,sf_cmul(lft[im][i], wave[im][j]));
#endif
}
curr[j] = c;
}
}
if (!mig) { /* modeling -> write out data */
sf_complexwrite(dat,nx,data);
}
}
sf_warning(".");
if (timer)
{
t1 = gtod_timer();
time = t1-t0;
sf_warning("Time = %lf\n",time);
}
if (mig) {
/* transpose */
for (ix=0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
img[ix][iz] = curr[ix+iz*nx2];
}
}
sf_complexwrite(img[0],nzx,image);
}
cfft2_finalize();
exit(0);
}
int cfft2_init(int pad1 /* padding on the first axis */,
int nx, int ny /* input data size */,
int *nx2, int *ny2 /* padded data size */)
/*< initialize >*/
{
#ifdef SF_HAS_FFTW
#ifdef _OPENMP
fftwf_init_threads();
if (false)
sf_warning("Using threaded FFTW3! \n");
fftwf_plan_with_nthreads(omp_get_max_threads());
#else
if (false)
sf_warning("Using FFTW3! \n");
#endif
#else
if (false)
sf_warning("Using KissFFT! \n");
#endif
#ifndef SF_HAS_FFTW
int i2;
#endif
nk = n1 = kiss_fft_next_fast_size(nx*pad1);
n2 = kiss_fft_next_fast_size(ny);
cc = sf_complexalloc2(n1,n2);
#ifdef SF_HAS_FFTW
dd = sf_complexalloc2(nk,n2);
cfg = fftwf_plan_dft_2d(n2,n1,
(fftwf_complex *) cc[0],
(fftwf_complex *) dd[0],
FFTW_FORWARD, FFTW_MEASURE);
icfg = fftwf_plan_dft_2d(n2,n1,
(fftwf_complex *) dd[0],
(fftwf_complex *) cc[0],
FFTW_BACKWARD, FFTW_MEASURE);
if (NULL == cfg || NULL == icfg) sf_error("FFTW failure.");
#else
cfg1 = kiss_fft_alloc(n1,0,NULL,NULL);
icfg1 = kiss_fft_alloc(n1,1,NULL,NULL);
cfg2 = kiss_fft_alloc(n2,0,NULL,NULL);
icfg2 = kiss_fft_alloc(n2,1,NULL,NULL);
tmp = (kiss_fft_cpx **) sf_alloc(n2,sizeof(*tmp));
tmp[0] = (kiss_fft_cpx *) sf_alloc(nk*n2,sizeof(kiss_fft_cpx));
#ifdef _OPENMP
#pragma omp parallel for private(i2) default(shared)
#endif
for (i2=0; i2 < n2; i2++) {
tmp[i2] = tmp[0]+i2*nk;
}
trace2 = sf_complexalloc(n2);
ctrace2 = (kiss_fft_cpx *) trace2;
#endif
*nx2 = n1;
*ny2 = n2;
wt = 1.0/(n1*n2);
return (nk*n2);
}
int main(int argc, char* argv[])
{
bool verb;
int nx,nv,np,nw,nh, ix,iv,ip,iw,ih;
float v0,v2,v1,v,dv, dx,dp,dw,dh, x0,p0,w0,h0, x,p,w,h;
sf_complex *ctrace, **ctrace2, shift;
sf_file in, out;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
if (SF_COMPLEX != sf_gettype(in)) sf_error("Need complex input");
if (!sf_histint(in,"n1",&nw)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&nh)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&nx)) sf_error("No n3= in input");
if (!sf_histint(in,"n4",&np)) sf_error("No n4= in input");
if (!sf_getbool("verb",&verb)) verb=true;
/* verbosity flag */
if (!sf_histfloat(in,"o1",&w0)) w0=0.;
if (!sf_histfloat(in,"d1",&dw)) sf_error("No d1= in input");
if (!sf_getint("nv",&nv)) sf_error("Need nv=");
/* velocity steps */
if (!sf_getfloat("dv",&dv)) sf_error("Need dv=");
/* velocity step size */
if (!sf_getfloat("v0",&v0) &&
!sf_histfloat(in,"v0",&v0)) sf_error("Need v0=");
/*( v0 starting velocity )*/
if(!sf_histfloat(in,"d2",&dh)) sf_error("No d2= in input");
if(!sf_histfloat(in,"d3",&dx)) sf_error("No d3= in input");
if(!sf_histfloat(in,"d4",&dp)) sf_error("No d4= in input");
if(!sf_histfloat(in,"o2",&h0)) h0=0.;
if(!sf_histfloat(in,"o3",&x0)) x0=0.;
if(!sf_histfloat(in,"o4",&p0)) sf_error("No o4= in input");
sf_putfloat(out,"o2",v0+dv);
sf_putfloat(out,"d2",dv);
sf_putint(out,"n2",nv);
sf_putstring(out,"label2","Velocity");
dx *= 2.*SF_PI;
x0 *= 2.*SF_PI;
dw *= 2.*SF_PI;
w0 *= 2.*SF_PI;
ctrace = sf_complexalloc(nw);
ctrace2 = sf_complexalloc2(nw,nv);
for (ip=0; ip < np; ip++) {
if (verb) sf_warning("slope %d of %d;", ip+1,np);
p = p0+ip*dp;
for (ix=0; ix < nx; ix++) {
x = x0+ix*dx;
for (iv=0; iv < nv; iv++) {
for (iw=0; iw < nw; iw++) {
ctrace2[iv][iw] = sf_cmplx(0.,0.);
}
}
for (ih=0; ih < nh; ih++) {
h = h0+ih*dh;
h *= 4.0f * h;
sf_complexread(ctrace,nw,in);
for (iv=0; iv < nv; iv++) {
v = v0 + (iv+1)*dv;
v2 = ((v0*v0) - (v*v));
v1 = h*(1.0/(v0*v0) - 1.0/(v*v));
for (iw=0; iw < nw; iw++) {
w = w0+iw*dw;
w = - 0.25f * 0.25f * (v2 * p * (p * w + 2.0f * x) + w*v1);
shift = sf_cmplx(cosf(w),sinf(w));
#ifdef SF_HAS_COMPLEX_H
ctrace2[iv][iw] += ctrace[iw] * shift;
#else
ctrace2[iv][iw] = sf_cadd(ctrace2[iv][iw],sf_cmul(ctrace[iw],shift));
#endif
} /* w */
} /* v */
} /* h */
sf_complexwrite(ctrace2[0],nw*nv,out);
} /* x */
} /* p */
if (verb) sf_warning(".");
exit (0);
}
int main(int argc, char *argv[])
{
int nw, n1, n2, n4, iw, i1, i2, i4, s1, x1, s2, x2, m, fold;
int jumpo, jumps, newn1, newn2, tn;
float d1, d2, newd1, newd2;
bool verb, stack, both;
sf_complex *dd, *ref=NULL, *mm=NULL, *mtemp=NULL;
sf_file in, out, dif=NULL;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (SF_COMPLEX != sf_gettype(in)) sf_error("Need complex input");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&nw)) sf_error("No n3= in input");
if (!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input");
if (!sf_histfloat(in,"d2",&d2)) sf_error("No d2= in input");
if (d1!=d2) sf_error("Need d1==d2");
n4 = sf_leftsize(in,3);
fold = 0;
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
if (!sf_getbool("stack",&stack)) stack=false;
/* stack flag, if y, no common multiple gather */
if (!sf_getbool("both",&both)) both=false;
/* receiver flag, if y, receiver with both sides */
if (!stack) {
if (!sf_getint("jumpo",&jumpo)) jumpo=1;
/* jump in offset dimension, only for stack=n */
if (!sf_getint("jumps",&jumps)) jumps=1;
/* jump in shot dimension, only for stack=n */
}
newn1 = n1;
newn2 = n2;
if (!stack) {
if (!both) {
sf_putint(out,"n1",(2*n1-1));
sf_putfloat(out,"d1",d1);
sf_putfloat(out,"o1",(1-n1)*d1);
} else {
sf_putint(out,"n1",n1);
sf_putfloat(out,"d1",d1);
sf_putfloat(out,"o1",(-1*n1/2)*d1);
}
(void) sf_shiftdim(in, out, 1);
if (n1%jumpo == 0) {
newn1 = n1 / jumpo;
} else {
newn1 = n1 / jumpo +1;
}
if (n2%jumps == 0) {
newn2 = n2 / jumps;
} else {
newn2 = n2 / jumps +1;
}
newd1 = (float) (d1 * jumpo);
newd2 = (float) (d2 * jumps);
sf_putint(out,"n2",newn1);
sf_putfloat(out,"d2",newd1);
sf_putint(out,"n3",newn2);
sf_putfloat(out,"d3",newd2);
}
if (NULL != sf_getstring ("dif")) {
dif = sf_input("dif");
ref = sf_complexalloc(n1*n2);
} else {
dif = NULL;
}
dd = sf_complexalloc(n1*n2);
if (stack) {
mm = sf_complexalloc(n1*n2);
} else {
if (!both) {
mm = sf_complexalloc((2*n1-1)*n1*n2);
mtemp = sf_complexalloc((2*n1-1)*newn1*newn2);
} else {
mm = sf_complexalloc(n1*n1*n2);
mtemp = sf_complexalloc(n1*newn1*newn2);
}
}
/* loop over n4 */
for (i4=0; i4 < n4; i4++) {
if (verb) sf_warning("slice %d of %d",i4+1,n4);
for (iw=0; iw < nw; iw++) { /* loop over frequency */
if (verb) sf_warning("frequency %d of %d;",iw+1,nw);
sf_complexread(dd,n1*n2,in);
if (NULL != dif) {
sf_complexread(ref,n1*n2,dif);
}
if (!both) {
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
mm[i2*n1+i1] = sf_cmplx(0.,0.);
fold = 0;
for (m=(-1*n1+1); m < n1; m++) {
if (m < 0) {
x1 = -1*m;
s1 = i2 + m;
x2 = i1 - m;
s2 = m + i2;
} else if ((i1-m) < 0) {
x1 = m;
s1 = i2;
x2 = m - i1;
s2 = i2 + i1;
} else {
x1 = m;
s1 = i2;
x2 = i1 - m;
s2 = m + i2;
}
if (stack) {
if (s1 >= 0 && s1 < n2 && x1 >= 0 && x1 < n1 &&
s2 >= 0 && s2 < n2 && x2 >= 0 && x2 < n1 ) {
#ifdef SF_HAS_COMPLEX_H
if(NULL != dif) {
mm[i2*n1+i1] += dd[s1*n1+x1]*ref[s2*n1+x2];
} else {
mm[i2*n1+i1] += dd[s1*n1+x1]*dd[s2*n1+x2];
}
#else
if(NULL != dif) {
mm[i2*n1+i1] = sf_cadd(mm[i2*n1+i1],sf_cmul(dd[s1*n1+x1],ref[s2*n1+x2]));
} else {
mm[i2*n1+i1] = sf_cadd(mm[i2*n1+i1],sf_cmul(dd[s1*n1+x1],dd[s2*n1+x2]));
}
#endif
} else {
mm[i2*n1+i1] = sf_cmplx(0.,0.);
}
if (0.0 != cabsf(mm[i2*n1+i1])) fold++;
} else {
if (s1 >= 0 && s1 < n2 && x1 >= 0 && x1 < n1 &&
s2 >= 0 && s2 < n2 && x2 >= 0 && x2 < n1 ) {
#ifdef SF_HAS_COMPLEX_H
if(NULL != dif) {
mm[i2*(2*n1-1)*n1+i1*(2*n1-1)+m+n1-1] = dd[s1*n1+x1]*ref[s2*n1+x2];
} else {
mm[i2*(2*n1-1)*n1+i1*(2*n1-1)+m+n1-1] = dd[s1*n1+x1]*dd[s2*n1+x2];
}
#else
if(NULL != dif) {
mm[i2*(2*n1-1)*n1+i1*(2*n1-1)+m+n1-1] = sf_cmul(dd[s1*n1+x1],ref[s2*n1+x2]);
} else {
mm[i2*(2*n1-1)*n1+i1*(2*n1-1)+m+n1-1] = sf_cmul(dd[s1*n1+x1],dd[s2*n1+x2]);
}
#endif
} else {
mm[i2*(2*n1-1)*n1+i1*(2*n1-1)+m+n1-1] = sf_cmplx(0.,0.);
}
}
}
if (stack) {
#ifdef SF_HAS_COMPLEX_H
mm[i2*n1+i1] = mm[i2*n1+i1]/(fold+SF_EPS);
#else
mm[i2*n1+i1] = sf_crmul(mm[i2*n1+i1],1.0/(fold+SF_EPS));
#endif
}
}
}
if (!stack) {
tn = 0;
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
if ((i2 % jumps == 0) && (i1 % jumpo == 0)) {
for (m=(-1*n1+1); m < n1; m++) {
mtemp[tn] = mm[i2*(2*n1-1)*n1+i1*(2*n1-1)+m+n1-1];
tn ++;
}
}
}
}
if (tn!=(2*n1-1)*newn1*newn2) sf_error("jump error!");
sf_complexwrite(mtemp,tn,out);
} else {
sf_complexwrite(mm,n1*n2,out);
}
} else {
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
mm[i2*n1+i1] = sf_cmplx(0.,0.);
fold = 0;
for (m=0; m < n1; m++) {
x1 = m;
s1 = i2;
x2 = i1 - m + n1/2;
s2 = m + i2 - n1/2;
if (stack) {
if (s1 >= 0 && s1 < n2 && x1 >= 0 && x1 < n1 &&
s2 >= 0 && s2 < n2 && x2 >= 0 && x2 < n1 ) {
#ifdef SF_HAS_COMPLEX_H
if(NULL != dif) {
mm[i2*n1+i1] += dd[s1*n1+x1]*ref[s2*n1+x2];
} else {
mm[i2*n1+i1] += dd[s1*n1+x1]*dd[s2*n1+x2];
}
#else
if(NULL != dif) {
mm[i2*n1+i1] = sf_cadd(mm[i2*n1+i1],sf_cmul(dd[s1*n1+x1],ref[s2*n1+x2]));
} else {
mm[i2*n1+i1] = sf_cadd(mm[i2*n1+i1],sf_cmul(dd[s1*n1+x1],dd[s2*n1+x2]));
}
#endif
} else {
mm[i2*n1+i1] = sf_cmplx(0.,0.);
}
if (0.0 != cabsf(mm[i2*n1+i1])) fold++;
} else {
if (s1 >= 0 && s1 < n2 && x1 >= 0 && x1 < n1 &&
s2 >= 0 && s2 < n2 && x2 >= 0 && x2 < n1 ) {
#ifdef SF_HAS_COMPLEX_H
if(NULL != dif) {
mm[i2*n1*n1+i1*n1+m] = dd[s1*n1+x1]*ref[s2*n1+x2];
} else {
mm[i2*n1*n1+i1*n1+m] = dd[s1*n1+x1]*dd[s2*n1+x2];
}
#else
if(NULL != dif) {
mm[i2*n1*n1+i1*n1+m] = sf_cmul(dd[s1*n1+x1],ref[s2*n1+x2]);
} else {
mm[i2*n1*n1+i1*n1+m] = sf_cmul(dd[s1*n1+x1],dd[s2*n1+x2]);
}
#endif
} else {
mm[i2*n1*n1+i1*n1+m] = sf_cmplx(0.,0.);
}
}
}
if (stack) {
#ifdef SF_HAS_COMPLEX_H
mm[i2*n1+i1] = mm[i2*n1+i1]/(fold+SF_EPS);
#else
mm[i2*n1+i1] = sf_crmul(mm[i2*n1+i1],1.0/(fold+SF_EPS));
#endif
}
}
}
if (!stack) {
tn = 0;
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
if (i2 % jumps == 0 && i1 % jumpo == 0) {
for (m=0; m < n1; m++) {
mtemp[tn] = mm[i2*n1*n1+i1*n1+m];
tn ++;
}
}
}
}
if (tn!=n1*newn1*newn2) sf_error("jump error!");
sf_complexwrite(mtemp,tn,out);
} else {
sf_complexwrite(mm,n1*n2,out);
}
}
}
if (verb) sf_warning(".");
}
exit(0);
}
int main(int argc, char* argv[])
{
bool inv, dip, verb, decomp;
int i, i1, n1, iw, nw, i2, n2, rect, niter, n12, nt, ip, np;
char *label;
float t, d1, w, w0, dw, p0, dp, p;
sf_complex *trace, *kbsc, *sscc=NULL;
sf_file in, out, basis;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (SF_COMPLEX != sf_gettype(in)) sf_error("Need complex input");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histfloat(in,"d1",&d1)) d1=1.;
label = sf_histstring(in,"label1");
if (!sf_getbool("inv",&inv)) inv=false;
/* if y, do inverse transform */
if (!sf_getbool("verb",&verb)) verb = false;
/* verbosity flag */
if (!sf_getbool("dip",&dip)) dip = false;
/* if y, do dip decomposition */
if (!sf_getbool("decompose",&decomp)) decomp = false;
/* if y, output decomposition */
if (NULL != sf_getstring("basis")) {
basis = sf_output("basis");
} else {
basis = NULL;
}
if (!inv) {
n2 = sf_leftsize(in,1);
sf_shiftdim(in, out, 2);
if (!sf_getint("rect",&rect)) rect=10;
/* smoothing radius (in time, samples) */
if (!sf_getint("niter",&niter)) niter=100;
/* number of inversion iterations */
if (dip) {
if (!sf_getint("np",&np)) sf_error("Need np=");
/* number of slopes */
if (!sf_getfloat("dp",&dp)) sf_error("Need dp=");
/* slope step */
if (!sf_getfloat("p0",&p0)) sf_error("Need p0=");
/* first slope */
sf_putint(out,"n2",np);
sf_putfloat(out,"d2",dp);
sf_putfloat(out,"o2",p0);
sf_putstring(out,"label2","Slope");
sf_putstring(out,"unit2","");
if (!sf_histint(in,"n2",&nw)) nw=1;
if (!sf_histfloat(in,"d2",&dw)) dw=1.;
if (!sf_histfloat(in,"o2",&w0)) w0=0.;
} else {
if (!sf_getint("nw",&nw)) nw = kiss_fft_next_fast_size(n1);
/* number of frequencies */
if (!sf_getfloat("dw",&dw)) dw = 1./(nw*d1);
/* frequency step */
if (!sf_getfloat("w0",&w0)) w0=-0.5/d1;
/* first frequency */
sf_putint(out,"n2",nw);
sf_putfloat(out,"d2",dw);
sf_putfloat(out,"o2",w0);
if (NULL != label && !sf_fft_label(2,label,out))
sf_putstring(out,"label2","Wavenumber");
sf_fft_unit(2,sf_histstring(in,"unit1"),out);
}
} else {
n2 = sf_leftsize(in,2);
if (dip) {
if (!sf_histint(in,"n2",&np)) sf_error("No n2= in input");
if (!sf_histfloat(in,"d2",&dp)) sf_error("No d2= in input");
if (!sf_histfloat(in,"o2",&p0)) sf_error("No o2= in input");
if (!sf_histint(in,"n2",&nw)) nw=1;
if (!sf_histfloat(in,"d3",&dw)) dw=1.;
if (!sf_histfloat(in,"o3",&w0)) w0=0.;
} else {
if (!sf_histint(in,"n2",&nw)) sf_error("No n2= in input");
if (!sf_histfloat(in,"d2",&dw)) sf_error("No d2= in input");
if (!sf_histfloat(in,"o2",&w0)) sf_error("No o2= in input");
}
sf_unshiftdim(in, out, 2);
}
if (NULL != basis) {
sf_shiftdim(in, basis, 2);
if (dip) {
sf_putint(basis,"n2",np);
sf_putfloat(basis,"d2",dp);
sf_putfloat(basis,"o2",p0);
sf_putstring(basis,"label2","Slope");
sf_putstring(basis,"unit2","");
} else {
sf_putint(basis,"n2",nw);
sf_putfloat(basis,"d2",dw);
sf_putfloat(basis,"o2",w0);
if (NULL != label && !sf_fft_label(2,label,basis))
sf_putstring(basis,"label2","Wavenumber");
sf_fft_unit(2,sf_histstring(in,"unit1"),out);
}
}
nt = dip? np:nw;
n12 = nt*n1;
dw *= 2.*SF_PI;
w0 *= 2.*SF_PI;
trace = sf_complexalloc(n1);
kbsc = sf_complexalloc(n12);
sscc = sf_complexalloc(n12);
if (!dip) {
/* basis functions */
for (iw=0; iw < nw; iw++) {
w = w0 + iw*dw;
for (i1=0; i1 < n1; i1++) {
t = i1*d1;
kbsc[iw*n1+i1] = sf_cmplx(cosf(w*t),sinf(w*t));
}
}
if (NULL != basis) {
sf_complexwrite(kbsc,n12,basis);
}
}
if (!inv) cmultidivn_init(nt, 1, n1, &n1, &rect, kbsc, (bool) (verb && (n2 < 500)));
for (i2=0; i2 < n2; i2++) {
sf_warning("slice %d of %d;",i2+1,n2);
if (dip) {
w = w0 + (i2 % nw)*dw;
for (ip=0; ip < np; ip++) {
p = -w*(p0 + ip*dp);
for (i1=0; i1 < n1; i1++) {
t = i1*d1;
kbsc[ip*n1+i1] = sf_cmplx(cosf(p*t),sinf(p*t));
}
}
if (NULL != basis) {
sf_complexwrite(kbsc,n12,basis);
}
}
if (!inv) {
sf_complexread(trace,n1,in);
cmultidivn (trace,sscc,niter);
if (decomp) {
for (iw=0; iw < nt; iw++) {
for (i1=0; i1 < n1; i1++) {
i = iw*n1+i1;
#ifdef SF_HAS_COMPLEX_H
sscc[i] *= kbsc[i];
#else
sscc[i1] = sf_cmul(sscc[i],kbsc[i]);
#endif
}
}
}
sf_complexwrite(sscc,n12,out);
} else {
for (i1=0; i1 < n1; i1++) {
trace[i1] = sf_cmplx(0.,0.);
}
sf_complexread(sscc,n12,in);
for (iw=0; iw < nt; iw++) {
for (i1=0; i1 < n1; i1++) {
i = iw*n1+i1;
#ifdef SF_HAS_COMPLEX_H
trace[i1] += sscc[i]*kbsc[i];
#else
trace[i1] = sf_cadd(trace[i1],sf_cmul(sscc[i],kbsc[i]));
#endif
}
}
sf_complexwrite(trace,n1,out);
}
}
sf_warning(".");
exit(0);
}
int main(int argc, char* argv[])
{
int nw,nh,nx, iw,ix,ih, k;
float dw, h0,dh,dx, w0,w,w2, h,h2;
sf_complex diag, diag2, *in=NULL, *out=NULL, offd, offd2, c1, c2;
bool all;
ctris slv;
sf_file input=NULL, output=NULL;
sf_init (argc,argv);
input = sf_input("in");
output = sf_output("out");
if (SF_COMPLEX != sf_gettype(input)) sf_error("Need complex input");
if (!sf_histint(input,"n1",&nx)) sf_error("No n1= in input");
if (!sf_histint(input,"n2",&nw)) sf_error("No n2= in input");
if (!sf_histfloat(input,"d1",&dx)) sf_error("No d1= in input");
if (!sf_histfloat(input,"d2",&dw)) sf_error("No d2= in input");
if (!sf_histfloat(input,"o2",&w0)) sf_error("No o2= in input");
if (!sf_getint("nh",&nh)) sf_error("Need nh=");
/* Number of steps in offset */
if (!sf_getfloat("dh",&dh)) sf_error("Need dh=");
/* Offset step size */
if (!sf_getfloat("h0",&h0)) sf_error("Need h0=");
/* Initial offset */
if (!sf_getbool("all",&all)) all=false;
/* if y, output all offsets */
if (all) {
sf_putint(output,"n2",nh+1);
sf_putfloat(output,"d2",dh);
sf_putfloat(output,"o2",h0);
sf_putint(output,"n3",nw);
sf_putfloat(output,"d3",dw);
sf_putfloat(output,"o3",w0);
}
dh /= dx;
h0 /= dx;
w0 *= 2.*SF_PI;
dw *= 2.*SF_PI;
in = sf_complexalloc(nx);
out = sf_complexalloc(nx);
slv = ctridiagonal_init (nx);
for (iw=0; iw < nw; iw++) {
sf_warning("frequency %d of %d;",iw+1,nw);
w = w0+iw*dw;
w2 = w*w;
sf_complexread(out,nx,input);
if (fabsf(w) < dw) {
for (ix=0; ix < nx; ix++) {
out[ix]=sf_cmplx(0.,0.);
}
if (all) {
for (ih=0; ih < nh; ih++) {
sf_complexwrite (out,nx,output);
}
}
sf_complexwrite (out,nx,output);
continue;
}
#ifdef SF_HAS_COMPLEX_H
c1 = 3.*sf_cmplx(9. + w2,4.*w)/(w2*sf_cmplx(3.,- w));
c2 = 3.*sf_cmplx(w2 - 27.,8.*w)/(w2*sf_cmplx(3.,- w));
#else
c1 = sf_cdiv(sf_cmplx(3.*(9. + w2),3.*4.*w),
sf_cmplx(w2*3.,-w2*w));
c2 = sf_cdiv(sf_cmplx(3.*(w2 - 27.),3.*8.*w),
sf_cmplx(w2*3.,-w2*w));
#endif
for (ih=0; ih < nh; ih++) {
if (all) sf_complexwrite (out,nx,output);
for (ix=0; ix < nx; ix++) {
in[ix] = out[ix];
}
h = h0 + ih*dh;
h2 = h+dh;
h *= h;
h2 *= h2;
#ifdef SF_HAS_COMPLEX_H
offd = 1. - c1*h2 + c2*h;
offd2 = 1. - c1*h + c2*h2;
diag = 12. - 2.*offd;
diag2 = 12. - 2.*offd2;
#else
offd = sf_cadd(sf_cmplx(1.,0.),
sf_cadd(sf_crmul(c1,-h2),
sf_crmul(c2,h)));
offd2 = sf_cadd(sf_cmplx(1.,0.),
sf_cadd(sf_crmul(c1,-h),
sf_crmul(c2,h2)));
diag = sf_cadd(sf_cmplx(12.,0.),sf_crmul(offd,-2.));
diag2 = sf_cadd(sf_cmplx(12.,0.),sf_crmul(offd2,-2.));
#endif
ctridiagonal_const_define (slv, diag2, offd2);
#ifdef SF_HAS_COMPLEX_H
out[0] = diag*in[0] + offd*in[1];
#else
out[0] = sf_cadd(sf_cmul(diag,in[0]),
sf_cmul(offd,in[1]));
#endif
for (k = 1; k < nx - 1; k++) {
#ifdef SF_HAS_COMPLEX_H
out[k] = diag*in[k] + offd*(in[k+1]+in[k-1]);
#else
out[k] = sf_cadd(sf_cmul(diag,in[k]),
sf_cmul(offd,sf_cadd(in[k+1],in[k-1])));
#endif
}
#ifdef SF_HAS_COMPLEX_H
out[nx-1] = diag*in[nx-1] + offd*in[nx-2];
#else
out[nx-1] = sf_cadd(sf_cmul(diag,in[nx-1]),
sf_cmul(offd,in[nx-2]));
#endif
ctridiagonal_solve (slv, out);
}
sf_complexwrite (out,nx,output);
}
sf_warning(".");
exit(0);
}
int main(int argc,char**argv)
{
void* h=NULL;
sf_file in, out;
float w0, f0, t0, v0, a0, qv, qa, wvp[4];
int event, wvtype, a0ref;
float d1, d2, o1, o2;
int n1, n2, i2, nfft;
sf_complex * buf;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in, "n1", &n1)) sf_error("No n2= in input");
if (!sf_histint(in, "n2", &n2)) sf_error("No n2= in input");
if (!sf_histfloat(in, "d1", &d1)) sf_error("No d1= in input");
if (!sf_histfloat(in, "d2", &d2)) sf_error("No d2= in input");
if (!sf_histfloat(in, "o1", &o1)) sf_error("No o1= in input");
if (!sf_histfloat(in, "o2", &o2)) sf_error("No o2= in input");
if(!sf_getint("wvtype", &wvtype)) wvtype =0;
/* 0: ricker; 1: sinc; x: not support */
switch(wvtype)
{
case 0:
case 1:
if(!sf_getfloat("w0", &w0) ) w0 = 35.0;
/* central frequency of Ricker wavelet or bandwidth of sinc wavelet */
wvp[0] = w0;
break;
}
if(!sf_getint("event", &event)) event =2;
/* 0: linear; 1: parabolic; 2:hyperbolic */
if(!sf_getint("nfft", &nfft)) sf_error("nfft= must given");
/* fft length */
if(!sf_getfloat("t0", &t0)) t0 =0.3;
/* event travel time at x=0 */
if(!sf_getfloat("v0", &v0)) v0 =1500.0;
/* event velocity at x=0, for reference frequency f0 */
if(!sf_getfloat("a0", &a0)) a0 =1.0;
/* event amplitude at t=a0ref (x=0) */
if(!sf_getfloat("qv", &qv)) qv = -1.0;
/* Q factor for velocity dispersion */
if(!sf_getfloat("qa", &qa) ) qa = qv;
/* Q factor for amplitude attenuation */
if(!sf_getfloat("f0", &f0)) f0 = w0;
/* reference frequency for velocity dispersion and amplitude attenuation */
if(!sf_getint("a0ref", &a0ref) ) a0ref = 0;
/* reference point for a0: 0 - t0; 1 - a0 */
h = sf_addevent_init(nfft, o1,d1,
wvtype, wvp,
event, t0, v0, a0,
qv, qa, f0, a0ref);
buf = sf_complexalloc(n1);
for(i2=0;i2<n2;i2++)
{
sf_complexread(buf, n1, in);
sf_addevent(h , fabs(d2*i2+o2), buf);
sf_complexwrite(buf, n1, out);
}
sf_addevent_close(h);
return 0;
}
int lrosfor2(sf_complex ***wavfld, float **sill, sf_complex **rcd, bool verb,
sf_complex **lt, sf_complex **rt, int m2,
geopar geop, sf_complex *ww, float *rr, int pad1, bool illum)
/*< low-rank one-step forward modeling >*/
{
int it,iz,im,ik,ix,i,j; /* index variables */
int nxb,nzb,gpz,gpx,gpl,snpint,wfit;
int nt,nz,nx, nk, nz2, nx2, nzx2;
float dt;
sf_complex c;
sf_complex *cwave, *cwavem;
sf_complex **wave, *curr;
#ifdef _OPENMP
int nth;
#endif
nx = geop->nx;
nz = geop->nz;
nxb = geop->nxb;
nzb = geop->nzb;
/* dx = geop->dx;
dz = geop->dz; */
/* spx = geop->spx;
spz = geop->spz; */
gpz = geop->gpz;
gpx = geop->gpx;
gpl = geop->gpl;
snpint = geop->snpint;
nt = geop->nt;
dt = geop->dt;
#ifdef _OPENMP
#pragma omp parallel
{
nth = omp_get_num_threads();
}
sf_warning(">>>> Using %d threads <<<<<", nth);
#endif
/*Matrix dimensions*/
nk = cfft2_init(pad1,nzb,nxb,&nz2,&nx2);
/* nzx = nzb*nxb; */
nzx2 = nz2*nx2;
curr = sf_complexalloc(nzx2);
cwave = sf_complexalloc(nk);
cwavem = sf_complexalloc(nk);
wave = sf_complexalloc2(nzx2,m2);
icfft2_allocate(cwavem);
#ifdef _OPENMP
#pragma omp parallel for private(iz)
#endif
for (iz=0; iz < nzx2; iz++) {
curr[iz] = sf_cmplx(0.,0.);
}
if (illum) {
#ifdef _OPENMP
#pragma omp parallel for private(iz)
#endif
for (ix=0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
sill[ix][iz] = 0.f;
}
}
}
/*Main loop*/
wfit = 0;
for (it = 0; it < nt; it++) {
if (verb) sf_warning("Forward source it=%d/%d;", it, nt-1);
/*matrix multiplication*/
cfft2(curr,cwave);
for (im = 0; im < m2; 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,lt,wave)
#endif
for (ix = 0; ix < nxb; ix++) {
for (iz=0; iz < nzb; iz++) {
i = iz+ix*nzb; /* original grid */
j = iz+ix*nz2; /* padded grid */
if ((it*dt)<=geop->trunc) {
#ifdef SF_HAS_COMPLEX_H
c = ww[it] * rr[i]; // source term
#else
c = sf_crmul(ww[it], rr[i]); // source term
#endif
} else {
c = sf_cmplx(0.,0.);
}
for (im = 0; im < m2; im++) {
#ifdef SF_HAS_COMPLEX_H
c += lt[im][i]*wave[im][j];
#else
c = sf_cadd(c,sf_cmul(lt[im][i], wave[im][j]));
#endif
}
curr[j] = c;
}
}
#ifdef _OPENMP
#pragma omp parallel for private(ix,j)
#endif
for ( ix =0 ; ix < gpl; ix++) {
j = (gpz+geop->top)+(ix+gpx+geop->lft)*nz2; /* padded grid */
rcd[ix][it] = curr[j];
}
if ( it%snpint == 0 ) {
#ifdef _OPENMP
#pragma omp parallel for private(ix,iz,j)
#endif
for ( ix = 0; ix < nx; ix++) {
for ( iz = 0; iz<nz; iz++ ) {
j = (iz+geop->top)+(ix+geop->lft)*nz2; /* padded grid */
wavfld[wfit][ix][iz] = curr[j];
if (illum) sill[ix][iz] += pow(hypotf(crealf(curr[j]),cimagf(curr[j])),2);
}
}
wfit++;
}
} /*Main loop*/
if (verb) sf_warning(".");
cfft2_finalize();
return wfit;
}
