int main (int argc, char *argv[]) { int n123, niter, order, i,j, liter, dim; int n[SF_MAX_DIM], rect[2], nr, ir; float a0, *u, *p; bool verb; sf_file in, out, sn, cs; sf_init(argc,argv); in = sf_input ("in"); out = sf_output ("out"); if (SF_FLOAT != sf_gettype(in)) sf_error("Need float type"); dim = sf_filedims(in,n); if (dim < 2) n[1]=1; n123 = n[0]*n[1]; nr = 1; for (j=2; j < dim; j++) { nr *= n[j]; } if (!sf_getint("niter",&niter)) niter=5; /* number of iterations */ if (!sf_getint("liter",&liter)) liter=50; /* number of linear iterations */ if (!sf_getint("rect1",&rect[0])) rect[0]=1; /* dip smoothness on 1st axis */ if (!sf_getint("rect2",&rect[1])) rect[1]=1; /* dip smoothness on 2nd axis */ if (!sf_getfloat("a0",&a0)) a0=0.; /* initial dip */ if (!sf_getint("order",&order)) order=1; /* accuracy order */ if (!sf_getbool("verb",&verb)) verb = true; /* verbosity flag */ sf_shiftdim(in, out, 3); sf_putint(out,"n3",2); /* initialize dip estimation */ odip2_init(n[0], n[1], rect, liter, verb); u = sf_floatalloc(n123); p = sf_floatalloc(2*n123); if (NULL != sf_getstring("sin")) { /* initial dip (sine) */ sn = sf_input("sin"); } else { sn = NULL; } if (NULL != sf_getstring("cos")) { /* initial dip (cosine) */ cs = sf_input("cos"); } else { cs = NULL; } for (ir=0; ir < nr; ir++) { /* initialize t-x dip */ if (NULL != sn) { sf_floatread(p,n123,sn); } else { for(i=0; i < n123; i++) { p[i] = 0.0f; } } if (NULL != cs) { sf_floatread(p+n123,n123,cs); } else { for(i=0; i < n123; i++) { p[n123+i] = 1.0f; } } /* read data */ sf_floatread(u,n123,in); /* estimate dip */ odip2(niter, order, u, p); /* write dip */ sf_floatwrite(p,2*n123,out); } exit (0); }
int main(int argc, char *argv[]) { int i, k, n1, n2, n12, n[2], niter, iter, liter, rect[2]; float mean, a0, ai, norm, norm2, lam; float **dat, **ang, **p1, **p2, ***den, *dena, *rat, **out; sf_file inp, dip; sf_init(argc,argv); inp = sf_input("in"); dip = 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"); n12 = n1*n2; n[0] = n1; n[1] = n2; if (!sf_getint("liter",&liter)) liter=100; /* number of linear iterations */ if (!sf_getint("niter",&niter)) niter=10; /* number of iterations */ if (!sf_getint("rect1",&rect[0])) rect[0]=1; /* vertical smoothing */ if (!sf_getint("rect2",&rect[1])) rect[1]=1; /* horizontal smoothing */ if (!sf_getfloat("a0",&a0)) a0=0; /* initial angle */ dat = sf_floatalloc2(n1,n2); ang = sf_floatalloc2(n1,n2); out = sf_floatalloc2(n1,n2); p1 = sf_floatalloc2(n1,n2); p2 = sf_floatalloc2(n1,n2); den = sf_floatalloc3(n1,n2,2); dena = sf_floatalloc(n12); rat = sf_floatalloc(n12); sf_floatread(dat[0],n12,inp); for (i=0; i < n12; i++) { ang[0][i] = a0; p1[0][i] = sinf(a0); p2[0][i] = cosf(a0); } opwd_init(n1,n2); sf_divn_init(2, n12, n, rect, liter, true); opwd_filter(lagrange,lagrange,NULL,NULL,p1,p2,dat,out); norm = 0.; for (i=0; i < n12; i++) { out[0][i] = dat[0][i] - out[0][i]; norm += out[0][i]*out[0][i]; } for (iter=0; iter < niter; iter++) { sf_warning("iter=%d of %d",iter+1,niter); opwd_filter(lagrange_der,lagrange,NULL,NULL,p1,p2,dat,den[0]); opwd_filter(lagrange,lagrange_der,NULL,NULL,p1,p2,dat,den[1]); for(i=0; i < n12; i++) { dena[i] = den[0][0][i]*p2[0][i]-den[1][0][i]*p1[0][i]; } mean = 0.; for(i=0; i < n12; i++) { mean += dena[i]*dena[i]; } mean = sqrtf (n12/mean); for(i=0; i < n12; i++) { out[0][i] *= mean; dena[i] *= mean; } sf_divn (out[0],dena,rat); /* Choose step size */ lam = 1.; for (k=0; k < 8; k++) { for(i=0; i < n12; i++) { ai = ang[0][i] + lam*rat[i]; if (ai < -0.5*SF_PI) ai=-0.5*SF_PI; else if (ai > 0.5*SF_PI) ai= 0.5*SF_PI; p1[0][i] = sinf(ai); p2[0][i] = cosf(ai); } opwd_filter(lagrange,lagrange,NULL,NULL,p1,p2,dat,out); norm2 = 0.; for (i=0; i < n12; i++) { out[0][i] = dat[0][i] - out[0][i]; norm2 += out[0][i]*out[0][i]; } if (norm2 < norm) break; lam *= 0.5; } for(i=0; i < n12; i++) { ang[0][i] += lam*rat[i]; norm = norm2; } } sf_floatwrite(ang[0],n12,dip); 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; 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[]) { bool verb,fsrf,snap,expl,dabc,abcone,is2D,cfl; bool ignore_interpolation = false; /* ignore interpolation for receivers - makes code faster, but only works when receivers are on grid points */ int jsnap,ntsnap,jdata; float fmax, safety; enum SourceType srctype; /* I/O files */ sf_file Fwav=NULL; /* wavelet */ sf_file Fsou=NULL; /* sources */ sf_file Frec=NULL; /* receivers */ sf_file Fvel=NULL; /* velocity */ sf_file Fden=NULL; /* density */ sf_file Fdat=NULL; /* data */ sf_file Fwfl=NULL; /* wavefield */ /*set all y variables to be either zero or null to avoid compiler warnings about being uninitialized */ /* cube axes */ sf_axis at,az,ax,ay=NULL; sf_axis as,ar; int nt,nz,nx,ny=0,ns,nr,nb; int it,iz,ix,iy=0; float dt,dz,dx,dy=0,idz,idx,idy=0; /* I/O arrays */ float *ww=NULL; /* wavelet */ float *dd=NULL; /* data */ /* FD operator size */ float co,cax,cbx,cay,cby,caz,cbz; /* wavefield cut params */ sf_axis acz=NULL,acx=NULL,acy=NULL; int nqz,nqx,nqy; float oqz,oqx,oqy; float dqz,dqx,dqy; /*------------------------------------------------------------*/ /* init RSF */ sf_init(argc,argv); /*------------------------------------------------------------*/ /* OMP parameters */ if( !sf_getbool("ignint",&ignore_interpolation)) ignore_interpolation = false; 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("expl",&expl)) expl=false; /* "exploding reflector" */ if(! sf_getbool("dabc",&dabc)) dabc=false; /* absorbing BC */ if(! sf_getbool("cfl",&cfl)) cfl=false; /* Use CFL check */ if(! sf_getbool("abcone",&abcone)) abcone=false; /* Use Zero-incident boundary condition*/ int ttype = 0; if(! sf_getint("srctype",&ttype)) ttype = 0; /* source type, see comments */ if(ttype < 0 || ttype > 1) sf_error("Invalid source type specified"); srctype = ttype; if (cfl) { if(! sf_getfloat("fmax",&fmax)) { /* max frequency for cfl check */ sf_error("CFL: Must specify fmax for CFL check"); } if(! sf_getfloat("safety",&safety) || safety < 0.0) safety= 0.8; /*safety factor for cfl check*/ } /*------------------------------------------------------------*/ /*------------------------------------------------------------*/ /* I/O files */ Fwav = sf_input ("in" ); /* wavelet */ Fvel = sf_input ("vel"); /* velocity */ Fsou = sf_input ("sou"); /* sources */ Frec = sf_input ("rec"); /* receivers */ Fwfl = sf_output("wfl"); /* wavefield */ Fdat = sf_output("out"); /* data */ Fden = sf_input ("den"); /* density */ /* Determine dimensionality, if 2D then axis 3 has n size of 1 */ sf_axis test = sf_iaxa(Fvel,3); if(sf_n(test) == 1) is2D = true; else is2D = false; /*------------------------------------------------------------*/ /* axes */ at = sf_iaxa(Fwav,2); sf_setlabel(at,"t"); if(verb) sf_raxa(at); /* time */ az = sf_iaxa(Fvel,1); sf_setlabel(az,"z"); if(verb) sf_raxa(az); /* depth */ ax = sf_iaxa(Fvel,2); sf_setlabel(ax,"x"); if(verb) sf_raxa(ax); /* space */ as = sf_iaxa(Fsou,2); sf_setlabel(as,"s"); if(verb) sf_raxa(as); /* sources */ ar = sf_iaxa(Frec,2); sf_setlabel(ar,"r"); 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); ns = sf_n(as); nr = sf_n(ar); if(!is2D){ /*If 3D*/ ay=sf_iaxa(Fvel,3); sf_setlabel(ay,"y"); if(verb) sf_raxa(ay); /*space*/ ny=sf_n(ay); dy=sf_d(ay); } /*------------------------------------------------------------*/ /*------------------------------------------------------------*/ /* other execution parameters */ if(! sf_getint("jdata",&jdata)) jdata=1; if(snap) { /* save wavefield every *jsnap* time steps */ if(! sf_getint("jsnap",&jsnap)) jsnap=nt; } /*------------------------------------------------------------*/ if(is2D){ /* Begin 2d code */ /* FDM structure */ fdm2d fdm=NULL; abcone2d abc=NULL; sponge spo=NULL; pt2d *ss=NULL; /* sources */ pt2d *rr=NULL; /* receivers */ float **tt=NULL; float **ro=NULL; /* density */ float **roz=NULL; /* normalized 1st derivative of density on axis 1 */ float **rox=NULL; /* normalized 1st derivative of density on axis 2 */ float **vp=NULL; /* velocity */ float **vt=NULL; /* temporary vp*vp * dt*dt */ float **um,**uo,**up,**ua,**ut; /* wavefield: um = U @ t-1; uo = U @ t; up = U @ t+1 */ /* linear interpolation weights/indices */ lint2d cs,cr; float **uc=NULL; /*------------------------------------------------------------*/ /* expand domain for FD operators and ABC */ if( !sf_getint("nb",&nb) || nb<NOP) nb=NOP; fdm=fdutil_init(verb,fsrf,az,ax,nb,1); /*------------------------------------------------------------*/ /*------------------------------------------------------------*/ /* setup output data header */ sf_oaxa(Fdat,ar,1); sf_setn(at,nt/jdata); sf_setd(at,dt*jdata); sf_oaxa(Fdat,at,2); /* 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_getfloat("oqz",&oqz)) oqz=sf_o(az); if(!sf_getfloat("oqx",&oqx)) oqx=sf_o(ax); sf_setn(az,fdm->nzpad); sf_seto(az,fdm->ozpad); if(verb) sf_raxa(az); sf_setn(ax,fdm->nxpad); sf_seto(ax,fdm->oxpad); if(verb) sf_raxa(ax); dqz=sf_d(az); dqx=sf_d(ax); acz = sf_maxa(nqz,oqz,dqz); sf_raxa(acz); acx = sf_maxa(nqx,oqx,dqx); sf_raxa(acx); /* check if the imaging window fits in the wavefield domain */ uc=sf_floatalloc2(sf_n(acz),sf_n(acx)); ntsnap=0; for(it=0; it<nt; it++) { if(it%jsnap==0) ntsnap++; } sf_setn(at, ntsnap); sf_setd(at,dt*jsnap); if(verb) sf_raxa(at); sf_oaxa(Fwfl,acz,1); sf_oaxa(Fwfl,acx,2); sf_oaxa(Fwfl,at, 3); } if(expl) { ww = sf_floatalloc( 1); } else { ww = sf_floatalloc(ns); } dd = sf_floatalloc(nr); /*------------------------------------------------------------*/ /* setup source/receiver coordinates */ ss = (pt2d*) sf_alloc(ns,sizeof(*ss)); rr = (pt2d*) sf_alloc(nr,sizeof(*rr)); pt2dread1(Fsou,ss,ns,2); /* read (x,z) coordinates */ pt2dread1(Frec,rr,nr,2); /* read (x,z) coordinates */ cs = lint2d_make(ns,ss,fdm); cr = lint2d_make(nr,rr,fdm); /*------------------------------------------------------------*/ /* setup FD coefficients */ idz = 1/dz; idx = 1/dx; co = C0 * (idx*idx+idz*idz); cax= CA * idx*idx; cbx= CB * idx*idx; caz= CA * idz*idz; cbz= CB * idz*idz; /*------------------------------------------------------------*/ tt = sf_floatalloc2(nz,nx); ro =sf_floatalloc2(fdm->nzpad,fdm->nxpad); roz =sf_floatalloc2(fdm->nzpad,fdm->nxpad); rox =sf_floatalloc2(fdm->nzpad,fdm->nxpad); vp =sf_floatalloc2(fdm->nzpad,fdm->nxpad); vt =sf_floatalloc2(fdm->nzpad,fdm->nxpad); /* input density */ sf_floatread(tt[0],nz*nx,Fden); expand(tt,ro ,fdm); /* normalized density derivatives */ for (ix=NOP; ix<fdm->nxpad-NOP; ix++) { for(iz=NOP; iz<fdm->nzpad-NOP; iz++) { roz[ix][iz] = DZ(ro,ix,iz,idz) / ro[ix][iz]; rox[ix][iz] = DX(ro,ix,iz,idx) / ro[ix][iz]; } } free(*ro); free(ro); /* input velocity */ sf_floatread(tt[0],nz*nx,Fvel ); expand(tt,vp,fdm); float vpmax = 0.0; float vpmin = 10000000000000000; /* precompute vp^2 * dt^2 */ for (ix=0; ix<fdm->nxpad; ix++) { for(iz=0; iz<fdm->nzpad; iz++) { vt[ix][iz] = vp[ix][iz] * vp[ix][iz] * dt*dt; if (vp[ix][iz] < vpmin) vpmin = vp[ix][iz]; else if (vp[ix][iz] > vpmax) vpmax = vp[ix][iz]; } } if (cfl) cfl_acoustic(vpmin,vpmax,dx,-1.0f,dz,dt,fmax,safety,NUM_INTERVALS); if(fsrf) { /* free surface */ for (ix=0; ix<fdm->nxpad; ix++) { for(iz=0; iz<fdm->nb; iz++) { vt[ix][iz]=0; } } } free(*tt); free(tt); /*------------------------------------------------------------*/ /*------------------------------------------------------------*/ /* allocate wavefield arrays */ um=sf_floatalloc2(fdm->nzpad,fdm->nxpad); uo=sf_floatalloc2(fdm->nzpad,fdm->nxpad); up=sf_floatalloc2(fdm->nzpad,fdm->nxpad); ua=sf_floatalloc2(fdm->nzpad,fdm->nxpad); for (ix=0; ix<fdm->nxpad; ix++) { for(iz=0; iz<fdm->nzpad; iz++) { um[ix][iz]=0; uo[ix][iz]=0; up[ix][iz]=0; ua[ix][iz]=0; } } /*------------------------------------------------------------*/ if (abcone) abc = abcone2d_make(NOP,dt,vp,fsrf,fdm); if(dabc) { /* one-way abc setup */ /* sponge abc setup */ spo = sponge_make(fdm->nb); } /*------------------------------------------------------------*/ /* * MAIN LOOP */ /*------------------------------------------------------------*/ if(verb) fprintf(stderr,"\n"); for (it=0; it<nt; it++) { if(verb) fprintf(stderr,"%d/%d \r",it,nt); #pragma omp parallel for \ schedule(dynamic) \ private(ix,iz) \ shared(fdm,ua,uo,co,caz,cbz) for (ix=NOP; ix<fdm->nxpad-NOP; ix++) { for(iz=NOP; iz<fdm->nzpad-NOP; iz++) { /* 4th order Laplacian operator */ ua[ix][iz] = co * uo[ix ][iz ] + caz*(uo[ix ][iz-1] + uo[ix ][iz+1]) + cbz*(uo[ix ][iz-2] + uo[ix ][iz+2]) ; /* density term */ /*ua[ix][iz] -= ( DZ(uo,ix,iz,idz) * roz[ix][iz] + DX(uo,ix,iz,idx) * rox[ix][iz] ); */ } } #pragma omp parallel for \ schedule(dynamic) \ private(ix,iz) \ shared(fdm,ua,uo,co,cax,cbx) for (ix=NOP; ix<fdm->nxpad-NOP; ix++) { for(iz=NOP; iz<fdm->nzpad-NOP; iz++) { ua[ix][iz] = ua[ix][iz] + cax*(uo[ix-1][iz ] + uo[ix+1][iz ]) + cbx*(uo[ix-2][iz ] + uo[ix+2][iz ]); } } /* inject acceleration source */ if (srctype == ACCELERATION){ if(expl) { sf_floatread(ww, 1,Fwav); lint2d_inject1(ua,ww[0],cs); } else { sf_floatread(ww,ns,Fwav); lint2d_inject(ua,ww,cs); } } /* step forward in time */ #pragma omp parallel for \ schedule(dynamic) \ private(ix,iz) \ shared(fdm,ua,uo,um,up,vt) for (ix=0; ix<fdm->nxpad; ix++) { for(iz=0; iz<fdm->nzpad; iz++) { up[ix][iz] = 2*uo[ix][iz] - um[ix][iz] + ua[ix][iz] * vt[ix][iz]; } } if(srctype == DISPLACEMENT){ if(expl) { sf_floatread(ww, 1,Fwav); lint2d_inject1(up,ww[0],cs); } else { sf_floatread(ww,ns,Fwav); lint2d_inject(up,ww,cs); } } /* circulate wavefield arrays */ ut=um; um=uo; uo=up; up=ut; if (abcone) abcone2d_apply(uo,um,NOP,abc,fdm); if(dabc) { /* one-way abc apply */ sponge2d_apply(um,spo,fdm); sponge2d_apply(uo,spo,fdm); sponge2d_apply(up,spo,fdm); } /* extract data */ if(ignore_interpolation){ cut2d_extract(uo,dd,cr); } else { lint2d_extract(uo,dd,cr); } if(snap && it%jsnap==0) { cut2d(uo,uc,fdm,acz,acx); sf_floatwrite(uc[0],sf_n(acz)*sf_n(acx),Fwfl); } if( it%jdata==0) sf_floatwrite(dd,nr,Fdat); } if(verb) fprintf(stderr,"\n"); /*------------------------------------------------------------*/ /* deallocate arrays */ free(*um); free(um); free(*up); free(up); free(*uo); free(uo); free(*ua); free(ua); if(snap) { free(*uc); free(uc); } free(*rox); free(rox); free(*roz); free(roz); free(*vp); free(vp); free(*vt); free(vt); free(ww); free(ss); free(rr); free(dd); exit (0); } else { /* FDM structure */ fdm3d fdm=NULL; abcone3d abc=NULL; sponge spo=NULL; /* I/O arrays */ pt3d *ss=NULL; /* sources */ pt3d *rr=NULL; /* receivers */ /* Non-universal arrays */ float***tt=NULL; float***ro=NULL; /* density */ float***roz=NULL; /* normalized 1st derivative of density on axis 1 */ float***rox=NULL; /* normalized 1st derivative of density on axis 2 */ float***roy=NULL; /* normalized 1st derivative of density on axis 3 */ float***vp=NULL; /* velocity */ float***vt=NULL; /* temporary vp*vp * dt*dt */ float***um,***uo,***up,***ua,***ut; /* wavefield: um = U @ t-1; uo = U @ t; up = U @ t+1 */ /* linear interpolation weights/indices */ lint3d cs,cr; /* Wavefield cut params that are not universal */ float ***uc=NULL; /*------------------------------------------------------------*/ /* 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); sf_setn(az,fdm->nzpad); sf_seto(az,fdm->ozpad); if(verb) sf_raxa(az); sf_setn(ax,fdm->nxpad); sf_seto(ax,fdm->oxpad); if(verb) sf_raxa(ax); sf_setn(ay,fdm->nypad); sf_seto(ay,fdm->oypad); if(verb) sf_raxa(ay); /*------------------------------------------------------------*/ /*------------------------------------------------------------*/ /* setup output data header */ sf_oaxa(Fdat,ar,1); sf_setn(at,nt/jdata); sf_setd(at,dt*jdata); sf_oaxa(Fdat,at,2); /* 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_raxa(acz); acx = sf_maxa(nqx,oqx,dqx); sf_raxa(acx); acy = sf_maxa(nqy,oqy,dqy); 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); if(verb) sf_raxa(at); sf_oaxa(Fwfl,acz,1); sf_oaxa(Fwfl,acx,2); sf_oaxa(Fwfl,acy,3); sf_oaxa(Fwfl,at, 4); } if(expl) { ww = sf_floatalloc( 1); } else { ww = sf_floatalloc(ns); } dd = sf_floatalloc(nr); /*------------------------------------------------------------*/ /* 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; co = C0 * (idx*idx+idy*idy+idz*idz); cax= CA * idx*idx; cbx= CB * idx*idx; cay= CA * idy*idy; cby= CB * idy*idy; caz= CA * idz*idz; cbz= CB * idz*idz; /*------------------------------------------------------------*/ tt = sf_floatalloc3(nz,nx,ny); ro =sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad); roz =sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad); rox =sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad); roy =sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad); vp =sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad); vt =sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad); /* input density */ sf_floatread(tt[0][0],nz*nx*ny,Fden); expand3d(tt,ro ,fdm); /* normalized density derivatives */ for (iy=NOP; iy<fdm->nypad-NOP; iy++) { for (ix=NOP; ix<fdm->nxpad-NOP; ix++) { for(iz=NOP; iz<fdm->nzpad-NOP; iz++) { roz[iy][ix][iz] = DZ3(ro,ix,iy,iz,idz) / ro[iy][ix][iz]; rox[iy][ix][iz] = DX3(ro,ix,iy,iz,idx) / ro[iy][ix][iz]; roy[iy][ix][iz] = DY3(ro,ix,iy,iz,idy) / ro[iy][ix][iz]; } } } free(**ro); free(*ro); free(ro); /* input velocity */ sf_floatread(tt[0][0],nz*nx*ny,Fvel ); expand3d(tt,vp,fdm); /* precompute vp^2 * dt^2 */ float vpmin = 1000000000000; float vpmax = 0.0; for (iy=0; iy<fdm->nypad; iy++) { for (ix=0; ix<fdm->nxpad; ix++) { for(iz=0; iz<fdm->nzpad; iz++) { float vpt = vp[iy][ix][iz]; vt[iy][ix][iz] = vp[iy][ix][iz] * vp[iy][ix][iz] * dt*dt; if (vpt > vpmax) vpmax = vpt; else if (vpt < vpmin) vpmin = vpt; } } } if (cfl) cfl_acoustic(vpmin,vpmax,dx,dy,dz,dt,fmax,safety,NUM_INTERVALS); if(fsrf) { /* free surface */ for (iy=0; iy<fdm->nypad; iy++) { for (ix=0; ix<fdm->nxpad; ix++) { for(iz=0; iz<fdm->nb; iz++) { vt[iy][ix][iz]=0; } } } } free(**tt); free(*tt); free(tt); /*------------------------------------------------------------*/ /*------------------------------------------------------------*/ /* allocate wavefield arrays */ um=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad); uo=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad); up=sf_floatalloc3(fdm->nzpad,fdm->nxpad,fdm->nypad); ua=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++) { um[iy][ix][iz]=0; uo[iy][ix][iz]=0; up[iy][ix][iz]=0; ua[iy][ix][iz]=0; } } } /*------------------------------------------------------------*/ if (abcone) abc = abcone3d_make(NOP,dt,vp,fsrf,fdm); if(dabc) { /* one-way abc setup */ /* sponge abc setup */ spo = sponge_make(fdm->nb); } /*------------------------------------------------------------*/ /* * MAIN LOOP */ /*------------------------------------------------------------*/ if(verb) fprintf(stderr,"\n"); for (it=0; it<nt; it++) { if(verb) fprintf(stderr,"%d/%d \r",it,nt); #pragma omp parallel for \ schedule(dynamic) \ private(ix,iy,iz) \ shared(fdm,ua,uo,co,cax,cay,caz,cbx,cby,cbz,idx,idy,idz) for (iy=NOP; iy<fdm->nypad-NOP; iy++) { for (ix=NOP; ix<fdm->nxpad-NOP; ix++) { for(iz=NOP; iz<fdm->nzpad-NOP; iz++) { /* 4th order Laplacian operator */ ua[iy][ix][iz] = co * uo[iy ][ix ][iz ] + caz*(uo[iy ][ix ][iz-1] + uo[iy ][ix ][iz+1]) + cbz*(uo[iy ][ix ][iz-2] + uo[iy ][ix ][iz+2]); /* density term */ /*ua[iy][ix][iz] -= ( DZ3(uo,ix,iy,iz,idz) * roz[iy][ix][iz] + DX3(uo,ix,iy,iz,idx) * rox[iy][ix][iz] + DY3(uo,ix,iy,iz,idy) * roy[iy][ix][iz] ); */ } } } #pragma omp parallel for \ schedule(dynamic) \ private(ix,iy,iz) \ shared(fdm,ua,uo,co,cax,cay,caz,cbx,cby,cbz,idx,idy,idz) for (iy=NOP; iy<fdm->nypad-NOP; iy++) { for (ix=NOP; ix<fdm->nxpad-NOP; ix++) { for(iz=NOP; iz<fdm->nzpad-NOP; iz++) { ua[iy][ix][iz] = ua[iy][ix][iz] + cax*(uo[iy ][ix-1][iz ] + uo[iy ][ix+1][iz ]) + cbx*(uo[iy ][ix-2][iz ] + uo[iy ][ix+2][iz ]) ; } } } #pragma omp parallel for \ schedule(dynamic) \ private(ix,iy,iz) \ shared(fdm,ua,uo,co,cax,cay,caz,cbx,cby,cbz,idx,idy,idz) for (iy=NOP; iy<fdm->nypad-NOP; iy++) { for (ix=NOP; ix<fdm->nxpad-NOP; ix++) { for(iz=NOP; iz<fdm->nzpad-NOP; iz++) { ua[iy][ix][iz] = ua[iy][ix][iz] + cay*(uo[iy-1][ix ][iz ] + uo[iy+1][ix ][iz ]) + cby*(uo[iy-2][ix ][iz ] + uo[iy+2][ix ][iz ]); } } } /* inject acceleration source */ if (srctype == ACCELERATION){ if(expl) { sf_floatread(ww, 1,Fwav); lint3d_inject1(ua,ww[0],cs); } else { sf_floatread(ww,ns,Fwav); lint3d_inject(ua,ww,cs); } } /* step forward in time */ #pragma omp parallel for \ schedule(static) \ private(ix,iy,iz) \ shared(fdm,ua,uo,um,up,vt) for (iy=0; iy<fdm->nypad; iy++) { for (ix=0; ix<fdm->nxpad; ix++) { for(iz=0; iz<fdm->nzpad; iz++) { up[iy][ix][iz] = 2*uo[iy][ix][iz] - um[iy][ix][iz] + ua[iy][ix][iz] * vt[iy][ix][iz]; } } } if (srctype == DISPLACEMENT) { if(expl) { sf_floatread(ww, 1,Fwav); lint3d_inject1(up,ww[0],cs); } else { sf_floatread(ww,ns,Fwav); lint3d_inject(up,ww,cs); } } /* circulate wavefield arrays */ ut=um; um=uo; uo=up; up=ut; if(abcone) abcone3d_apply(uo,um,NOP,abc,fdm); if(dabc) { /* one-way abc apply */ sponge3d_apply(um,spo,fdm); sponge3d_apply(uo,spo,fdm); sponge3d_apply(up,spo,fdm); } /* extract data */ if (ignore_interpolation) { cut3d_extract(uo,dd,cr); } else { lint3d_extract(uo,dd,cr); } if(snap && it%jsnap==0) { cut3d(uo,uc,fdm,acz,acx,acy); sf_floatwrite(uc[0][0],sf_n(acz)*sf_n(acx)*sf_n(acy),Fwfl); } if(it%jdata==0) sf_floatwrite(dd,nr,Fdat); } if(verb) fprintf(stderr,"\n"); /*------------------------------------------------------------*/ /* deallocate arrays */ free(**um); free(*um); free(um); free(**up); free(*up); free(up); free(**uo); free(*uo); free(uo); free(**ua); free(*ua); free(ua); if (snap) { free(**uc); free(*uc); free(uc); } free(**rox); free(*rox); free(rox); free(**roy); free(*roy); free(roy); free(**roz); free(*roz); free(roz); free(**vp); free(*vp); free(vp); free(**vt); free(*vt); free(vt); free(ss); free(rr); free(dd); free(ww); 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]; ); } } }
int main(int argc, char* argv[]) { bool phase; char *label; int i1, n1, iw, nt, nw, i2, n2, rect, niter; float t, d1, w, w0, dw, *trace, *bs, *bc, *ss, *cc, *mm; sf_file time, timefreq, mask; sf_init(argc,argv); time = sf_input("in"); timefreq = sf_output("out"); if (!sf_histint(time,"n1",&n1)) sf_error("No n1= in input"); if (!sf_histfloat(time,"d1",&d1)) d1=1.; n2 = sf_leftsize(time,1); if (!sf_getint("nw",&nw)) { /* number of frequencies */ nt = 2*kiss_fft_next_fast_size((n1+1)/2); nw = nt/2+1; dw = 1./(nt*d1); w0 = 0.; } else { if ( !sf_getfloat("dw",&dw)) { /* f requency step */ nt = 2*kiss_fft_next_fast_size((n1+1)/2); dw = 1./(nt*d1); } if (!sf_getfloat("w0",&w0)) w0=0.; /* first frequency */ } sf_shiftdim(time, timefreq, 2); sf_putint(timefreq,"n2",nw); sf_putfloat(timefreq,"d2",dw); sf_putfloat(timefreq,"o2",w0); if (NULL != (label = sf_histstring(time,"label1")) && !sf_fft_label(2,label,timefreq)) sf_putstring(timefreq,"label2","Wavenumber"); sf_fft_unit(2,sf_histstring(time,"unit1"),timefreq); dw *= 2.*SF_PI; w0 *= 2.*SF_PI; trace = sf_floatalloc(n1); bs = sf_floatalloc(n1); bc = sf_floatalloc(n1); ss = sf_floatalloc(n1); cc = sf_floatalloc(n1); if (!sf_getint("rect",&rect)) rect=10; /* smoothing radius */ if (!sf_getint("niter",&niter)) niter=100; /* number of inversion iterations */ if (!sf_getbool("phase",&phase)) phase=false; /* output phase instead of amplitude */ sf_divn_init(1,n1,&n1,&rect,niter,false); if (NULL != sf_getstring("mask")) { mask = sf_input("mask"); mm = sf_floatalloc(n1); } else { mask = NULL; mm = NULL; } for (i2=0; i2 < n2; i2++) { sf_floatread(trace,n1,time); if (NULL != mm) { sf_floatread(mm,n1,mask); for (i1=0; i1 < n1; i1++) { trace[i1] *= mm[i1]; } } for (iw=0; iw < nw; iw++) { w = w0 + iw*dw; if (0.==w) { /* zero frequency */ for (i1=0; i1 < n1; i1++) { ss[i1] = 0.; bc[i1] = 0.5; if (NULL != mm) bc[i1] *= mm[i1]; } sf_divn(trace,bc,cc); } else { for (i1=0; i1 < n1; i1++) { t = i1*d1; bs[i1] = sinf(w*t); bc[i1] = cosf(w*t); if (NULL != mm) { bs[i1] *= mm[i1]; bc[i1] *= mm[i1]; } } sf_divn(trace,bs,ss); sf_divn(trace,bc,cc); } for (i1=0; i1 < n1; i1++) { ss[i1] = phase? atan2f(ss[i1],cc[i1]): hypotf(ss[i1],cc[i1]); } sf_floatwrite(ss,n1,timefreq); } } exit(0); }
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[]) { sf_file in, out; int n[SF_MAX_DIM], dim, nr; float d[2], o[2]; int n1, n2; float d1, d2, o1, o2; int j, ir, i1, i2; float **ibuf, **obuf, x1, x2; sf_init(argc, argv); in = sf_input ("in"); out = sf_output ("out"); dim = sf_filedims(in,n); for(nr=1, j=2; j < dim; j++) nr *= n[j]; if (!sf_histint(in,"n1", n)) sf_error("n1"); if (!sf_histfloat(in,"o1", o)) sf_error("o1"); if (!sf_histfloat(in,"d1", d)) sf_error("d1"); if (!sf_histint(in,"n2", n+1)) sf_error("n2"); if (!sf_histfloat(in,"o2", o+1)) sf_error("o2"); if (!sf_histfloat(in,"d2", d+1)) sf_error("d2"); if (!sf_getfloat("o1",&o1)) o1=o[0]; /* first sample sample on 1st axis */ if (!sf_getfloat("d1",&d1)) d1=d[0]; /* sample interval on 1st axis */ if (!sf_getfloat("o2",&o2)) o2=o[1]; /* first sample on 2nd axis */ if (!sf_getfloat("d2",&d2)) d2=d[1]; /* sample interval on 2nd axis */ if(d[0]*(o1-o[0]) < 0) o1 = o[0]; if(d[1]*(o2-o[1]) < 0) o2 = o[1]; n1 = (d[0]*(n[0]-1)+o[0]-o1)/d1; n2 = (d[1]*(n[1]-1)+o[1]-o2)/d2; sf_putint(out,"n1", n1); sf_putfloat(out,"o1", o1); sf_putfloat(out,"d1", d1); sf_putint(out,"n2", n2); sf_putfloat(out,"o2", o2); sf_putfloat(out,"d2", d2); ibuf = sf_floatalloc2(n[0], n[1]); obuf = sf_floatalloc2(n1, n2); for(ir=0;ir<nr;ir++) { sf_floatread(ibuf[0], n[0]*n[1], in); for(i2=0; i2<n2; i2++) { x2 = (i2*d2 + o2 - o[1])/d[1]; for(i1=0; i1<n1; i1++) { x1 = (i1*d1 + o1 - o[0])/d[0]; obuf[i2][i1] = resample(ibuf, n1, n2, x1, x2); } } sf_floatwrite(obuf[0], n1*n2, out); } return 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); }