void source_map(int sx, int sz, int rectx, int rectz, int padnx, int padnz, int padnzx, float *rr) /*< generate source map >*/ { int i, j, i0; int n[2], s[2], rect[2]; bool diff[2], box[2]; sf_triangle tr; n[0]=padnz; n[1]=padnx; s[0]=1; s[1]=padnz; rect[0]=rectz; rect[1]=rectx; diff[0]=false; diff[1]=false; box[0]=false; box[1]=false; for (i=0; i<padnzx; i++) rr[i]=0.; for (i=0; i<nsource; i++){ j=(sx+i*dsource)*padnz+sz; rr[j]=1.; } for (i=0; i<2; i++){ if(rect[i] <=1) continue; tr=sf_triangle_init(rect[i], n[i], box[i]); for(j=0; j<padnzx/n[i]; j++){ i0=sf_first_index(i,j,2,n,s); sf_smooth2(tr,i0,s[i],diff[i],rr); } sf_triangle_close(tr); } }
void gradient_smooth2(int rectx, int rectz, int nx, int nz, int waterz, float scaling, float *grad) /*< smooth gradient, zero bathymetry layer and normalization >*/ { int i, j, i0, nzx; int n[2], s[2], rect[2]; bool diff[2], box[2]; sf_triangle tr; nzx=nz*nx; n[0]=nz; n[1]=nx; s[0]=1; s[1]=nz; rect[0]=rectz; rect[1]=rectx; diff[0]=false; diff[1]=false; box[0]=false; box[1]=false; for (i=0; i<2; i++){ if(rect[i] <=1) continue; tr=sf_triangle_init(rect[i], n[i], box[i]); for(j=0; j<nzx/n[i]; j++){ i0=sf_first_index(i,j,2,n,s); sf_smooth2(tr,i0,s[i],diff[i],grad); } sf_triangle_close(tr); } for(i=0; i<waterz; i++) for(j=0; j<nx; j++) grad[i+j*nz]=0.; for(i=0; i<nzx; i++) grad[i] *= scaling; }
void reflgen(int nzb, int nxb, int spz, int spx, int rectz, int rectx, int nrep, /*smoothing parameters*/ float *refl/*reflectivity map*/) /*< Generate reflectivity map with smoothing >*/ { int i, j, i0, irep; int nzx=nzb*nxb; sf_triangle tr; int n[2],s[2],rect[2]; bool diff[2],box[2]; n[0]=nzb; n[1]=nxb; s[0]=1; s[1]=nzb; rect[0]=rectz; rect[1]=rectx; diff[0]=false; diff[1]=false; box[0]=false; box[1]=false; j=spx*nzb+spz; /*point source position*/ refl[j]=1; /* 2-d triangle smoothing */ for (i=0;i<2;i++) { if (rect[i] <= 1) continue; tr = sf_triangle_init (rect[i],n[i],box[i]); for (j=0; j < nzx/n[i]; j++) { i0 = sf_first_index (i,j,2,n,s); for (irep=0; irep < nrep; irep++) { sf_smooth2 (tr,i0,s[i],diff[i],refl); } } sf_triangle_close(tr); } }
void reflgen(int nzb, int nxb, int spz, int spx, int rectz, int rectx, int nrep, /*smoothing parameters*/ float **refl/*reflectivity map*/) /*< Generate reflectivity map with smoothing >*/ { int iz, i, j, i0, irep, is; int nzx=nzb*nxb; sf_triangle tr; int n[2],s[2],rect[2]; bool diff[2],box[2]; n[0]=nzb; n[1]=nxb; s[0]=1; s[1]=nzb; rect[0]=rectz; rect[1]=rectx; diff[0]=false; diff[1]=false; box[0]=false; box[1]=false; for(is=0; is<nsource; is++) { #ifdef _OPENMP #pragma omp parallel for private(iz) #endif for (iz=0; iz < nzx; iz++) { refl[is][iz]=0; } j=(spx+is*dsource)*nzb+spz; /*point source position*/ refl[is][j]=0; if(choose==is || choose==nsource) refl[is][j]=1.; } for(is=0; is<nsource; is++) { /* 2-d triangle smoothing */ for (i=0; i<2; i++) { if (rect[i] <= 1) continue; tr = sf_triangle_init (rect[i],n[i],box[i]); for (j=0; j < nzx/n[i]; j++) { i0 = sf_first_index (i,j,2,n,s); for (irep=0; irep < nrep; irep++) { sf_smooth2 (tr,i0,s[i],diff[i],refl[is]); // why adjoint? } } sf_triangle_close(tr); } } }
void sf_trianglen_init (int ndim /* number of dimensions */, int *nbox /* triangle radius [ndim] */, int *ndat /* data dimensions [ndim] */) /*< initialize >*/ { int i; dim = ndim; n = sf_intalloc(dim); tr = (sf_triangle*) sf_alloc(dim,sizeof(sf_triangle)); nd = 1; for (i=0; i < dim; i++) { tr[i] = (nbox[i] > 1)? sf_triangle_init (nbox[i],ndat[i],false): NULL; s[i] = nd; n[i] = ndat[i]; nd *= ndat[i]; } tmp = sf_floatalloc (nd); }
int main (int argc, char* argv[]) { int nh, n1,n2, i1,i2, i, n12, niter, dim, n[SF_MAX_DIM], rect[SF_MAX_DIM]; int shrt, lng; float *trace, *hilb, *num, *den, *phase, mean, c; char key[6]; sf_triangle ts, tl; sf_file in, out; sf_init (argc,argv); in = sf_input("in"); out = sf_output("out"); if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input"); dim = sf_filedims (in,n); n1 = n[0]; n12 = 1; for (i=0; i < dim; i++) { snprintf(key,6,"rect%d",i+1); if (!sf_getint(key,rect+i)) rect[i]=1; n12 *= n[i]; } n2 = n12/n1; num = sf_floatalloc(n12); den = sf_floatalloc(n12); phase = sf_floatalloc(n12); if (!sf_getint("niter",&niter)) niter=100; /* number of iterations */ if (!sf_getint("order",&nh)) nh=10; /* Hilbert transformer order */ if (!sf_getfloat("ref",&c)) c=1.; /* Hilbert transformer reference (0.5 < ref <= 1) */ sf_hilbert_init(n1, nh, c); if (!sf_getint("short",&shrt)) shrt=1; /* short smoothing radius */ if (!sf_getint("long",&lng)) lng=10; /* long smoothing radius */ ts = sf_triangle_init(shrt,n1,false); tl = sf_triangle_init(lng,n1,false); mean=0.; for (i2=0; i2 < n2; i2++) { trace = num+n1*i2; hilb = den+n1*i2; sf_floatread(trace,n1,in); sf_hilbert(trace,hilb); for (i1=0; i1 < n1; i1++) { trace[i1] = hypotf(trace[i1],hilb[i1]); hilb[i1] = trace[i1]; } sf_smooth2 (ts, 0, 1, false, trace); sf_smooth2 (tl, 0, 1, false, hilb); for (i1=0; i1 < nh; i1++) { trace[i1] = 0.; hilb[i1] = 0.; } for (i1=nh; i1 < n1-nh; i1++) { mean += hilb[i1]*hilb[i1]; } for (i1=n1-nh; i1 < n1; i1++) { trace[i1] = 0.; hilb[i1] = 0.; } } mean = sqrtf(n12/mean); for (i=0; i < n12; i++) { num[i] *= mean; den[i] *= mean; } sf_divn_init(dim, n12, n, rect, niter, true); sf_divn (num, den, phase); sf_floatwrite(phase,n12,out); exit(0); }
int main(int argc, char* argv[]) { bool verb,conj,twin,pandq,Gtot,Htot; /* OMP parameters */ #ifdef _OPENMP int ompnth; #endif float *pplus0, *pplus, *pplusinv, *pplustemp, *Pplus, *Pplus_trace, *pminus, *Pminus, *Refl, *Gp, *Gm, *G, *H; float *qplus, *qplusinv, *qplustemp, *Qplus, *Qplus_trace, *qminus, *Qminus; float *window, *taper, pi; int *tw; /* I/O files */ sf_file Fplus; sf_file FRefl; sf_file FGp; sf_file FGm; sf_file FG; sf_file FH; sf_file Ftwin; sf_file Fp; sf_file Fq; char *filename1, filename2[256], filename3[256]; /* Cube axes */ sf_axis at,af,ax; int nt,nf,ntr,mode,nshots,niter,len; int i,it,ix,ishot,iter,i0; int twc, twa, shift, n[2], rect[2], s[2]; float scale,eps,dt,df,dx,ot,of,a,b,c,d,e,f; sf_triangle tr; /*------------------------------------------------------------*/ /* Initialize RSF parameters */ /*------------------------------------------------------------*/ sf_init(argc,argv); /*------------------------------------------------------------*/ /* Initialize OMP parameters */ /*------------------------------------------------------------*/ #ifdef _OPENMP ompnth=omp_init(); #endif /*------------------------------------------------------------*/ /* Flags */ /*------------------------------------------------------------*/ if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */ if(! sf_getbool("conj",&conj)) conj=false; /* complex conjugation (time-reversal) flag */ if(! sf_getbool("twin",&twin)) twin=false; /* returns the timewindow as one of the outputs */ if(! sf_getbool("pandq",&pandq)) pandq=false; /* pandq=true: returns p and q */ if(! sf_getbool("Gtot",&Gtot)) Gtot=false; /* Gtot=true: returns G=Gp+Gm */ if(! sf_getbool("Htot",&Htot)) Htot=false; /* Htot=true: returns H=Gp-Gm */ if(! sf_getint("niter",&niter)) niter=1; /* number of iterations */ if(! sf_getint("nshots",&nshots)) nshots=1; /* number of shots */ if(! sf_getfloat("scale",&scale)) scale=1.0; /* scale factor */ if(! sf_getfloat("eps",&eps)) eps=1e-4; /* threshold for the timewindow */ if(! sf_getint("shift",&shift)) shift=5; /* shift in samples for the timewindow */ if (verb) { fprintf(stderr,"This program was called with \"%s\".\n",argv[0]); /*fprintf(stderr,"Nr: %d Nx: %d Nt:%d\n",nr,nx,nt);*/ if (argc > 1) { for (i = 1; i<argc; i++) { fprintf(stderr,"argv[%d] = %s\n", i, argv[i]); } } else { fprintf(stderr,"The command had no other arguments.\n"); } } /*------------------------------------------------------------*/ /* I/O files */ /*------------------------------------------------------------*/ /* "in" is the transposed version of p00plus_xxxx_xxxx.rsf Dimensions of p00plus_xxxx_xxxx.rsf BEFORE sftransp: n1=ntr,n2=nt Dimensions of p00plus_xxxx_xxxx.rsf BEFORE sftransp: n1=nt,n2=ntr */ Fplus = sf_input("in"); /* refl is REFL_000.rsf It is used to read nf, df, of Dimensions are: n1=nf,n2=ntr */ /*FRefl = (sf_file)sf_alloc(1,sizeof(sf_file));*/ FRefl = sf_input("refl"); FGp = sf_output("out"); FGm = sf_output("Gm"); if (Gtot) { FG = sf_output("G"); } if (Htot) { FH = sf_output("H"); } if (pandq) { Fp = sf_output("p"); Fq = sf_output("q"); } if (twin) { Ftwin = sf_output("window"); /* time window */ } /*------------------------------------------------------------*/ /* Axes */ /*------------------------------------------------------------*/ at = sf_iaxa(Fplus,1); sf_setlabel(at,"Time"); if(verb) sf_raxa(at); /* time */ af = sf_iaxa(FRefl,1); sf_setlabel(af,"Frequency"); if(verb) sf_raxa(af); /* frequency */ ax = sf_iaxa(Fplus,2); sf_setlabel(ax,"r"); if(verb) sf_raxa(ax); /* space */ nt = sf_n(at); dt = sf_d(at); ot = sf_o(at); nf = sf_n(af); df = sf_d(af); of = sf_o(af); ntr = sf_n(ax); dx = sf_d(ax); if (verb) fprintf(stderr,"nt: %d nf: %d ntr:%d\n",nt,nf,ntr); sf_fileclose(FRefl); /*------------------------------------------------------------*/ /* Setup output data and wavefield header */ /*------------------------------------------------------------*/ sf_oaxa(FGp,at,1); sf_oaxa(FGp,ax,2); sf_oaxa(FGm,at,1); sf_oaxa(FGm,ax,2); if (Gtot) { sf_oaxa(FG,at,1); sf_oaxa(FG,ax,2); } if (Htot) { sf_oaxa(FH,at,1); sf_oaxa(FH,ax,2); } if (pandq) { sf_oaxa(Fp,at,1); sf_oaxa(Fp,ax,2); sf_oaxa(Fq,at,1); sf_oaxa(Fq,ax,2); } if (twin) { sf_oaxa(Ftwin,at,1); sf_oaxa(Ftwin,ax,2); } /*------------------------------------------------------------*/ /* Allocate arrays */ /*------------------------------------------------------------*/ /* Downgoing wavefields - Time */ pplus0 = (float *)calloc(nt*ntr,sizeof(float)); sf_floatread(pplus0,nt*ntr,Fplus); pplus = (float *)calloc(nt*ntr,sizeof(float)); memcpy(pplus,pplus0,nt*ntr*sizeof(float)); pplustemp = (float *)calloc(nt*ntr,sizeof(float)); pplusinv = (float *)calloc(nt*ntr,sizeof(float)); qplus = (float *)calloc(nt*ntr,sizeof(float)); qplustemp = (float *)calloc(nt*ntr,sizeof(float)); /* Downgoing wavefields - Frequency */ Pplus = (float *)calloc(2*nf*ntr,sizeof(float)); Qplus = (float *)calloc(2*nf*ntr,sizeof(float)); /* The three flags of fft1 are: inv, sym, and opt */ fft1(pplus0,Pplus,Fplus,0,0,1); memcpy(Qplus,Pplus,2*nf*ntr*sizeof(float)); /* Upgoing wavefields - Time */ pminus = (float *)calloc(nt*ntr,sizeof(float)); qminus = (float *)calloc(nt*ntr,sizeof(float)); /* Downgoing wavefields - Frequency */ Pminus = (float *)calloc(2*nf*ntr,sizeof(float)); Qminus = (float *)calloc(2*nf*ntr,sizeof(float)); /* This is currently NOT used */ /* Transpose of p00plus_xxxx_xxxx */ for (ix=0; ix<ntr; ix++) { for (it=0; it<nt; it++) { pplusinv[ix*ntr+it]=pplus0[it*ntr+ix]; } } /* Single trace (in frequency) of the downgoing wavefield */ Pplus_trace = (float *)calloc(2*nf,sizeof(float)); Qplus_trace = (float *)calloc(2*nf,sizeof(float)); /* Output wavefields */ Gp = (float *)calloc(nt*ntr,sizeof(float)); Gm = (float *)calloc(nt*ntr,sizeof(float)); if (Gtot) { G = (float *)calloc(nt*ntr,sizeof(float)); } if (Htot) { H = (float *)calloc(nt*ntr,sizeof(float)); } /* Time-reversal flag */ if (conj) { mode = -1; } else { mode = +1; } /* Load the reflection response into the memory */ if (verb) fprintf(stderr,"Before loading R %d\n",2*nf*ntr); Refl = (float *)calloc(2*nf*ntr*nshots,sizeof(float)); /* Read REFL_000.rsf */ filename1 = sf_getstring("refl"); /* 000.rsf are 7 characters */ len = strlen(filename1)-7; /* copy the filename without 000.rsf */ strncpy(filename2,filename1,len); filename2[len] = '\0'; if (verb) fprintf(stderr,"filename2 is: %s and len is: %d\n",filename2,len); /*if (NULL == filename1) { fprintf(stderr,"Cannot read header file %s",filename1); }*/ for (ishot=0; ishot<nshots; ishot++) { /* write xxx.rsf in the string filename3 */ sprintf(filename3,"%03d.rsf",ishot); for (i=0; i<7; i++) filename2[len+i] = filename3[i]; filename2[len+7] = '\0'; if (verb) fprintf(stderr,"Loading %s in memory\n",filename2); FRefl = sf_input(filename2); sf_floatread(&Refl[ishot*2*nf*ntr],2*nf*ntr,FRefl); sf_fileclose(FRefl); /*if (verb) fprintf(stderr,"Iteration %d\n",ishot);*/ } /* Build time-window */ tw = (int *)calloc(ntr,sizeof(int)); window = (float *)calloc(nt*ntr,sizeof(float)); /*memset(window,0,nt*ntr*sizeof(float));*/ /* I am not sure why I set it to this value */ /*for (ix=0; ix<ntr; ix++) { tw[ix] = nt*dt+ot+0.15; }*/ if (verb) fprintf(stderr,"Build the time-window\n"); for (ix=0; ix<ntr; ix++) { for (it=0; it<nt; it++) { if (pplus0[it+ix*nt]>eps) { /*tw[ix] = it*dt+ot;*/ tw[ix] = it; /*if (verb) fprintf(stderr,"%d %d\n",ix,it);*/ break; } } } for (ix=0; ix<ntr; ix++) { twc = (int)(tw[ix]-shift); twa = (int)(-twc+shift+nt); /*if (verb) fprintf(stderr,"%d %d\n",twc,twa);*/ for (it=0; it<nt; it++) { if ((it<twc) || (it>twa)) { window[it+ix*nt] = 1.0; } } } /* Smoothing of the window */ /* Should I implement flags for rect and iter? */ /* Look at Msmooth.c to understand below */ n[0] = nt; n[1] = ntr; s[0] = 1; s[1] = nt; rect[0] = 5; rect[1] = 5; for (ix=0; ix <= 1; ix++) { if (rect[ix] <= 1) continue; tr = sf_triangle_init (rect[ix],n[ix],false); for (it=0; it < (nt*ntr/n[ix]); it++) { i0 = sf_first_index (ix,it,1+1,n,s); for (iter=0; iter < 2; iter++) { sf_smooth2 (tr,i0,s[ix],false,window); } } sf_triangle_close(tr); } /* Tapering */ pi = 4.0*atan(1.0); /*fprintf(stderr,"pi: %f\n",pi); fprintf(stderr,"ntr: %d\n",ntr);*/ taper = (float *)calloc(ntr,sizeof(float)); memset(taper,0,ntr*sizeof(float)); for (ix=0; ix<151; ix++) { taper[ix] = (float)(0.5*(1.0-cos(2.0*pi*(ix-0.0)/300))); taper[ntr-ix-1] = taper[ix]; } /*for (ix=(ntr-1); ix>(701-151-1); ix--) { taper[ix] = (float)(0.5*(1.0-cos(2.0*pi*(ix-0.0)/300))); }*/ for (ix=151; ix<(ntr-151); ix++) { taper[ix] = 1.0; } /*for (ix=0; ix<ntr; ix++) { fprintf(stderr,"taper[%d]: %f\n",ix,taper[ix]); }*/ FRefl = sf_input("refl"); /*------------------------------------------------------------*/ /* Loop over iterations */ /*------------------------------------------------------------*/ if (verb) fprintf(stderr,"Beginning of loop over iterations\n"); for (iter=0; iter<niter; iter++) { /* Set Pminus and Qminus to 0 */ memset(Pminus,0,2*nf*ntr*sizeof(float)); memset(Qminus,0,2*nf*ntr*sizeof(float)); /*------------------------------------------------------------*/ /* Loop over shot positions */ /*------------------------------------------------------------*/ if (verb) fprintf(stderr,"Beginning of loop over shot positions\n"); for (ishot=0; ishot<nshots; ishot++) { /* Loop over receivers (traces) */ #ifdef _OPENMP #pragma omp parallel for private(ix,it,a,b,c,d,e,f) \ shared(Pminus,Qminus,Pplus,Qplus,taper,Refl) #endif for (ix=0; ix<ntr; ix++) { /* Loop over frequencies */ #pragma ivdep for (it=0; it<2*nf; it=it+2) { /*(x + yi)(u + vi) = (xu - yv) + (xv + yu)i*/ a = Refl[ix*2*nf+it+ishot*2*nf*ntr]*taper[ishot]; b = Refl[ix*2*nf+it+1+ishot*2*nf*ntr]*taper[ishot]; c = Pplus[ishot*2*nf+it]; d = Pplus[ishot*2*nf+it+1]; e = Qplus[ishot*2*nf+it]; f = Qplus[ishot*2*nf+it+1]; Pminus[ix*2*nf+it] += a*c - mode*b*d; Pminus[ix*2*nf+it+1] += mode*a*d + b*c; Qminus[ix*2*nf+it] += a*e - mode*b*f; Qminus[ix*2*nf+it+1] += mode*a*f + b*e; } /* End of loop over frequencies */ } /* End of loop over receivers (traces) */ if (verb) if(ishot%50==0) fprintf(stderr,"Trace %d\n",ishot); } /* End of loop over shot positions */ /* Save a copy of pplus and qplus before creating their next iteration */ memcpy(pplustemp,pplus,nt*ntr*sizeof(float)); memcpy(qplustemp,qplus,nt*ntr*sizeof(float)); /* Build the next iteration of Pplus and Qplus */ fft1(Pminus,pminus,FRefl,1,0,1); fft1(Qminus,qminus,FRefl,1,0,1); if (verb) fprintf(stderr,"Build the next iteration of pplus and qplus\n"); #ifdef _OPENMP #pragma omp parallel for private(ix,it) \ shared(pminus,qminus,pplus,qplus,pplus0,window) #endif for (ix=0; ix<ntr; ix++) { #pragma ivdep for (it=0; it<nt; it++) { pplus[it+ix*nt] = pplus0[it+ix*nt] - scale*window[it+ix*nt]*pminus[it+ix*nt]; qplus[it+ix*nt] = pplus0[it+ix*nt] + scale*window[it+ix*nt]*qminus[it+ix*nt]; } } fft1(pplus,Pplus,Fplus,0,0,1); fft1(qplus,Qplus,Fplus,0,0,1); if (verb) fprintf(stderr,"%d %d\n",ix,it); if(iter%10==0) fprintf(stderr,"Iteration %d\n",iter); } /* End of loop over iterations */ /* Build Gp and Gm */ if (verb) fprintf(stderr,"Build Gp and Gm\n"); #ifdef _OPENMP #pragma omp parallel for private(ix,it) \ shared(Gp,Gm,G,H,pminus,qminus,pplustemp,qplustemp,pplus0) #endif for (ix=0; ix<ntr; ix++) { #pragma ivdep for (it=0; it<nt; it++) { Gp[it+ix*nt] = 0.5*( pplustemp[it+ix*nt] + scale*pminus[it+ix*nt] + qplustemp[it+ix*nt] - scale*qminus[it+ix*nt] ); Gm[it+ix*nt] = 0.5*( pplustemp[it+ix*nt] + scale*pminus[it+ix*nt] - qplustemp[it+ix*nt] + scale*qminus[it+ix*nt] ); if (Gtot) { G[it+ix*nt] = pplustemp[it+ix*nt] + scale*pminus[it+ix*nt]; } if (Htot) { H[it+ix*nt] = qplustemp[it+ix*nt] - scale*qminus[it+ix*nt]; } /*p[it+ix*nt] = 1.0*( pplus[it+ix*nt] + scale*pminus[it+ix*nt] ); q[it+ix*nt] = 1.0*( qplus[it+ix*nt] - scale*qminus[it+ix*nt] );*/ } } /* Write the final result */ /*FRefl = sf_input(argv[1]);*/ /*fft1(Gp,,FRefl,1,0,0); fft1(Gm,,FRefl,1,0,0);*/ sf_floatwrite(Gp,nt*ntr,FGp); sf_floatwrite(Gm,nt*ntr,FGm); if (Gtot) { sf_floatwrite(G,nt*ntr,FG); sf_fileclose(FG); free(G); } if (Htot) { sf_floatwrite(H,nt*ntr,FH); sf_fileclose(FH); free(H); } if (pandq) { sf_floatwrite(pplustemp,nt*ntr,Fp); sf_floatwrite(pminus,nt*ntr,Fq); sf_fileclose(Fp); sf_fileclose(Fq); } if (twin) { sf_floatwrite(window,nt*ntr,Ftwin); sf_fileclose(Ftwin); } sf_fileclose(Fplus); sf_fileclose(FRefl); sf_fileclose(FGp); sf_fileclose(FGm); free(Gp); free(Gm); free(pplus); free(pplusinv); free(pplustemp); free(Pplus); free(Pplus_trace); free(Pminus); free(qplus); free(qplustemp); free(Qplus); free(Qplus_trace); free(Qminus); free(Refl); free(window); free(tw); free(filename1); exit (0); }
int main(int argc, char* argv[]) { int nt, nt2, nx, i1, i2, ch, n12, n122, fk; bool adj, sm, domod; float dt, dt2, dx, ot, ot2, ox, epst2; float v_1, v_2, v_3, v_4, eps, passthr; float * data, * output, * datat2, * outputt2, * smooth, * model; sf_file inp, out, pifk; /* smoothing variables */ int nrep, dim, dim1, n[SF_MAX_DIM], rect[SF_MAX_DIM], s[SF_MAX_DIM], i0, i, j, nvar; bool diff[SF_MAX_DIM], box[SF_MAX_DIM]; int irep; char key[6]; sf_triangle tr; /* kirchhoff params */ bool hd; int sw; float *vrms, v0; char *test; sf_file vel; //MADAGASCAR C API /* initialize */ sf_init(argc,argv); inp = sf_input("in"); out = sf_output("out"); /* get dimensions from input */ if (!sf_histint(inp,"n1",&nt)) sf_error("No n1= in inp"); if (!sf_histint(inp,"n2",&nx)) sf_error("No n2= in inp"); if (!sf_histfloat(inp,"d1",&dt)) sf_error("No d1= in inp"); if (!sf_histfloat(inp,"d2",&dx)) sf_error("No d2= in inp"); if (!sf_histfloat(inp,"o1",&ot)) sf_error("No o1= in inp"); if (!sf_histfloat(inp,"o2",&ox)) sf_error("No o2= in inp"); /* kirchhoff parameters */ if (!sf_getbool("hd",&hd)) hd=true; if (!sf_getbool("domod",&domod)) domod=true; /* if y, apply half-derivative filter */ if (!sf_getint("sw",&sw)) sw=0; /* if > 0, select a branch of the antialiasing operation */ /* smoothing part - determines various params including dimension along which smoothing is performed */ dim = sf_filedims (inp,n); dim1 = -1; for (i=0; i < dim; i++) { snprintf(key,6,"rect%d",i+1); if (!sf_getint(key,rect+i)) rect[i]=1; /*( rect#=(1,1,...) smoothing radius on #-th axis )*/ if (rect[i] > 1) dim1 = i; snprintf(key,6,"diff%d",i+1); if (!sf_getbool(key,diff+i)) diff[i]=false; /*( diff#=(n,n,...) differentiation on #-th axis )*/ snprintf(key,5,"box%d",i+1); if (!sf_getbool(key,box+i)) box[i]=false; /*( box#=(n,n,...) box (rather than triangle) on #-th axis )*/ } /* creating parameters for smoothing filter */ s[0] = 1; s[1] = nt; //s[2] = ny; for 3D case nvar = nt*nx; // 2D // nvar = nt*nx*ny; // 3D /* to output f-k pi filter */ if (NULL != sf_getstring("pifk")) { pifk = sf_output("pifk"); } else { pifk = NULL; } /* get parameters from command line */ if (!sf_getbool("adj",&adj)) adj=false; /* if perform derivative filtering */ if (!sf_getbool("sm",&sm)) sm=true; /* if y, do adjoint integration */ if (!sf_getfloat("v_1",&v_1)) sf_error("No integration range specified"); if (!sf_getfloat("v_2",&v_2)) sf_error("No integration range specified"); if (!sf_getfloat("v_3",&v_3)) sf_error("No integration range specified"); if (!sf_getfloat("v_4",&v_4)) sf_error("No integration range specified"); if (!sf_getfloat("passthr",&passthr)) passthr = 0.001; // threshold for tail elimination if (!sf_getfloat("eps",&eps)) eps = 0.001; // damper for pi if (!sf_getfloat("epst2",&epst2)) epst2 = 0.001; // damper for t2warp /* new axis length */ if (!sf_getint("pad",&nt2)) nt2=nt; /* output time samples */ if (!sf_getint("repeat",&nrep)) nrep=1; /* repeat filtering several times */ n12 = nt2*nx; data = sf_floatalloc(nt*nx); model = sf_floatalloc(nt*nx); datat2 = sf_floatalloc(nt2*nx); outputt2 = sf_floatalloc(nt2*nx); output = sf_floatalloc(nt*nx); /* allocate space for smoothing */ if(sm){ smooth = sf_floatalloc(nt*nx); } /* allocating and reading velocity */ vrms = sf_floatalloc(nt); if (NULL != (test = sf_getstring("velocity"))) { /* velocity file */ free(test); vel = sf_input("velocity"); sf_floatread(vrms,nt,vel); sf_fileclose(vel); } else { if (!sf_getfloat("v0",&v0)) sf_error("Need velocity= or v0="); /* constant velocity (if no velocity=) */ for (i1=0; i1 < nt; i1++) { vrms[i1] = v0; } } if(domod){// if perform modelling /* initialize kirchhoff */ kirchnew_init (vrms, ot, dt, dx, nt, nx, sw, true, hd); n122 = nt*nx; } if(!adj) { /* read data currently 2D */ if(domod){ for (i2=0; i2 < nx; i2++) { sf_floatread(model+i2*nt,nt,inp); } kirchnew_lop (false,false,n122,n122,model,data); } else { sf_warning("modelling is disabled"); for (i2=0; i2 < nx; i2++) { sf_floatread(data+i2*nt,nt,inp); } } // internal else } else {// adj flag /* read data currently 2D */ for (i2=0; i2 < nx; i2++) { sf_floatread(data+i2*nt,nt,inp); } } if (adj){ if (sm) { for (j = 0; j < nx; j++) { for (i = 0; i < nt; i++) { smooth[i + j*nt] = data [i + j*nt]; } } /* browse through dimensions and smooth*/ for (i=0; i <= dim1; i++) { if (rect[i] <= 1) continue; tr = sf_triangle_init (rect[i],n[i],box[i]); for (j=0; j < nvar/n[i]; j++) { i0 = sf_first_index (i,j,dim1+1,n,s); for (irep=0; irep < nrep; irep++) { sf_smooth (tr,i0,s[i],diff[i],smooth); } } } sf_warning("closing triangle"); sf_triangle_close(tr); for (j = 0; j < nx; j++) { for (i = 0; i < nt; i++) { data[i + j*nt] -= smooth[i + j*nt]; } } }// sm flag } /* t2warping axis evaluation */ ot2 = ot*ot; dt2 = ot+(nt-1)*dt; dt2 = (dt2*dt2 - ot2)/(nt2-1); /* take in account different output trace length */ t2warp_init(nt,nt2,nx,ot,dt,ot2,dt2,epst2); sf_warning("t2warp_init(nt,nt2,nx,ot,dt,ot2,dt2,epst2);\n"); /* compute pi filter */ flatpifilt_init(nt2, nx, dt2, dx, 0.001, v_1, v_2, v_3, v_4, eps); sf_warning("pifilt_init(nt2, nx, dt2, dx, v_a, v_b, v_0, beta, eps);\n"); if(adj) { sf_chain3(t2warp_inv,freqfilt4pi_lop,t2warp,adj,false,nt*nx,nt2*nx,nt2*nx,nt*nx,output,data,outputt2,datat2); } else { sf_chain3(t2warp_inv,freqfilt4pi_lop,t2warp,false,false,nt*nx,nt2*nx,nt2*nx,nt*nx,data,output,datat2,outputt2); //smoothing if (sm) { for (j = 0; j < nx; j++) { for (i = 0; i < nt; i++) { smooth[i + j*nt] = output [i + j*nt]; } } /* browse through dimensions and smooth*/ for (i=0; i <= dim1; i++) { if (rect[i] <= 1) continue; tr = sf_triangle_init (rect[i],n[i],box[i]); for (j=0; j < nvar/n[i]; j++) { i0 = sf_first_index (i,j,dim1+1,n,s); for (irep=0; irep < nrep; irep++) { sf_smooth2 (tr,i0,s[i],diff[i],smooth); } } } sf_triangle_close(tr); for (j = 0; j < nx; j++) { for (i = 0; i < nt; i++) { output [i + j*nt] -= smooth[i + j*nt]; } } }// smoothing flag } if(adj) { kirchnew_lop (true,false,n122,n122,model,output); sf_warning("chain is done;\n"); } // adj flag sf_warning("done with output"); if (!adj) { /* write */ for (i2=0; i2 < nx; i2++) { sf_floatwrite(output+i2*nt,nt,out); } } else { /* write */ for (i2=0; i2 < nx; i2++) { sf_floatwrite(model+i2*nt,nt,out); } } exit(0); }
int main (int argc, char* argv[]) { int dim, dim1, i, j, n[SF_MAX_DIM], rect[SF_MAX_DIM], s[SF_MAX_DIM]; int nrep, irep, n1, n2, i2, i0; bool adj, diff[SF_MAX_DIM], box[SF_MAX_DIM]; char key[6]; float* data; sf_triangle tr; sf_file in, out; sf_init (argc, argv); in = sf_input ("in"); out = sf_output ("out"); if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input"); dim = sf_filedims (in,n); dim1 = -1; for (i=0; i < dim; i++) { snprintf(key,6,"rect%d",i+1); if (!sf_getint(key,rect+i)) rect[i]=1; /*( rect#=(1,1,...) smoothing radius on #-th axis )*/ if (rect[i] > 1) dim1 = i; snprintf(key,6,"diff%d",i+1); if (!sf_getbool(key,diff+i)) diff[i]=false; /*( diff#=(n,n,...) differentiation on #-th axis )*/ snprintf(key,5,"box%d",i+1); if (!sf_getbool(key,box+i)) box[i]=false; /*( box#=(n,n,...) box (rather than triangle) on #-th axis )*/ } n1 = n2 = 1; for (i=0; i < dim; i++) { if (i <= dim1) { s[i] = n1; n1 *= n[i]; } else { n2 *= n[i]; } } data = sf_floatalloc (n1); if (!sf_getint("repeat",&nrep)) nrep=1; /* repeat filtering several times */ if (!sf_getbool("adj",&adj)) adj=false; /* run in the adjoint mode */ for (i2=0; i2 < n2; i2++) { sf_floatread(data,n1,in); for (i=0; i <= dim1; i++) { if (rect[i] <= 1) continue; tr = sf_triangle_init (rect[i],n[i],box[i]); for (j=0; j < n1/n[i]; j++) { i0 = sf_first_index (i,j,dim1+1,n,s); for (irep=0; irep < nrep; irep++) { if (adj) { sf_smooth (tr,i0,s[i],diff[i],data); } else { sf_smooth2 (tr,i0,s[i],diff[i],data); } } } sf_triangle_close(tr); } sf_floatwrite(data,n1,out); } exit (0); }
int main(int argc, char* argv[]) { bool verb,conj,twin,Pf1,PG; /* OMP parameters */ #ifdef _OPENMP int ompnth; #endif float *F_arrival, *Refl, *G, *Gm, *Gp, *f1pS, *f1p, *F1pS, *F1p; float *MS, *MS1, *F1m_0, *f1m_0, *F1m, *F1m1, *f1m, *ms, *gm, *gp; float *MS_0, *ms_0, *ms_2, *MS2; float *gp1, *gm1; float *window, *taper, pi; int *tw,allocated=0; /* I/O files */ sf_file FF_arrival; sf_file FRefl; sf_file FGp; sf_file FGm; sf_file FG; sf_file Ff1m; sf_file Ff1p; sf_file Ftwin; char *filename1, filename2[256], filename3[256]; /* Cube axes */ sf_axis at,af,ax,at1; int nt,nf,ntr,mode,nshots,niter,len; int i,it,ix,ishot,iter,i0; int twc, twa, shift, n[2], rect[2], s[2], tap; float scale,eps,dt,df,dx,ot,of,a,b,c,d,e,f,r; sf_triangle tr; /*------------------------------------------------------------*/ /* Initialize RSF parameters */ /*------------------------------------------------------------*/ sf_init(argc,argv); /*------------------------------------------------------------*/ /* Initialize OMP parameters */ /*------------------------------------------------------------*/ #ifdef _OPENMP ompnth=omp_init(); #endif /*------------------------------------------------------------*/ /* Flags */ /*------------------------------------------------------------*/ if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */ if(! sf_getbool("conj",&conj)) conj=false; /* complex conjugation (time-reversal) flag */ if(! sf_getbool("twin",&twin)) twin=false; /* returns the timewindow as one of the outputs */ if(! sf_getbool("Pf1",&Pf1)) Pf1=false; /* Htot=true: returns H=Gp-Gm */ if(! sf_getbool("PG",&PG)) PG=false; /* Htot=true: returns H=Gp-Gm */ if(! sf_getint("niter",&niter)) niter=1; /* number of iterations */ if(! sf_getint("nshots",&nshots)) nshots=1; /* number of shots */ if(! sf_getfloat("r",&r)) r=-1; /* reflection coefficient if flux normalised r=-1 */ if(! sf_getfloat("scale",&scale)) scale=1.0; /* scale factor */ if(! sf_getfloat("eps",&eps)) eps=1e-4; /* threshold for the timewindow */ if(! sf_getint("shift",&shift)) shift=5; /* shift in samples for the timewindow */ if(! sf_getint("tap",&tap)) tap=20; /* taper of R */ if (verb) { fprintf(stderr,"This program was called with \"%s\".\n",argv[0]); /*fprintf(stderr,"Nr: %d Nx: %d Nt:%d\n",nr,nx,nt);*/ if (argc > 1) { for (i = 1; i<argc; i++) { fprintf(stderr,"argv[%d] = %s\n", i, argv[i]); } } else { fprintf(stderr,"The command had no other arguments.\n"); } } /*------------------------------------------------------------*/ /* I/O files */ /*------------------------------------------------------------*/ /* "in" is the transposed version of p00plus_xxxx_xxxx.rsf Dimensions of p00plus_xxxx_xxxx.rsf BEFORE sftransp: n1=ntr,n2=nt Dimensions of p00plus_xxxx_xxxx.rsf BEFORE sftransp: n1=nt,n2=ntr */ FF_arrival = sf_input("in"); /* refl is REFL_000.rsf It is used to read nf, df, of Dimensions are: n1=nf,n2=ntr */ /*FRefl = (sf_file)sf_alloc(1,sizeof(sf_file));*/ FRefl = sf_input("refl"); FGp = sf_output("out"); FGm = sf_output("Gm"); if (PG) { FG = sf_output("G"); } if (Pf1) { Ff1p = sf_output("f1p"); Ff1m = sf_output("f1m"); } if (twin) { Ftwin = sf_output("window"); /* time window */ } /*------------------------------------------------------------*/ /* Axes */ /*------------------------------------------------------------*/ at = sf_iaxa(FF_arrival,1); sf_setlabel(at,"Time"); if(verb) sf_raxa(at); /* time */ at1 = sf_iaxa(FF_arrival,1); sf_setlabel(at,"Time"); if(verb) sf_raxa(at); /* time */ af = sf_iaxa(FRefl,1); sf_setlabel(af,"Frequency"); if(verb) sf_raxa(af); /* frequency */ ax = sf_iaxa(FF_arrival,2); sf_setlabel(ax,"r"); if(verb) sf_raxa(ax); /* space */ nt = sf_n(at); dt = sf_d(at); ot = sf_o(at); nf = sf_n(af); df = sf_d(af); of = sf_o(af); ntr = sf_n(ax); dx = sf_d(ax); int nt2=(nt/2); sf_setn(at1,nt2); if (verb) fprintf(stderr,"nt: %d nf: %d ntr:%d\n",nt,nf,ntr); sf_fileclose(FRefl); /*------------------------------------------------------------*/ /* Setup output data and wavefield header */ /*------------------------------------------------------------*/ sf_oaxa(FGp,at1,1); sf_oaxa(FGp,ax,2); sf_oaxa(FGm,at1,1); sf_oaxa(FGm,ax,2); if (PG) { sf_oaxa(FG,at1,1); sf_oaxa(FG,ax,2); } if (Pf1) { sf_oaxa(Ff1p,at,1); sf_oaxa(Ff1p,ax,2); sf_oaxa(Ff1m,at,1); sf_oaxa(Ff1m,ax,2); } if (twin) { sf_oaxa(Ftwin,at,1); sf_oaxa(Ftwin,ax,2); } /*------------------------------------------------------------*/ /* Allocate arrays */ /*------------------------------------------------------------*/ /* First arrival - Time */ F_arrival = (float *)calloc(nt*ntr,sizeof(float)); allocated+=nt*ntr; sf_floatread(F_arrival,nt*ntr,FF_arrival); ms = (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; ms_0 = (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; ms_2 = (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; f1m_0= (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; f1m = (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; f1pS = (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; f1p = (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; memcpy(ms,F_arrival,nt*ntr*sizeof(float));allocated+=nt*ntr; /* Allocate for coda M of f2 - Frequency */ MS = (float *)calloc(2*nf*ntr,sizeof(float));allocated+=2*nf*ntr; MS_0 = (float *)calloc(2*nf*ntr,sizeof(float));allocated+=2*nf*ntr; MS1 = (float *)calloc(2*nf*ntr,sizeof(float));allocated+=2*nf*ntr; MS2 = (float *)calloc(2*nf*ntr,sizeof(float));allocated+=2*nf*ntr; F1m_0= (float *)calloc(2*nf*ntr,sizeof(float));allocated+=2*nf*ntr; F1m = (float *)calloc(2*nf*ntr,sizeof(float));allocated+=2*nf*ntr; F1m1 = (float *)calloc(2*nf*ntr,sizeof(float));allocated+=2*nf*ntr; F1pS = (float *)calloc(2*nf*ntr,sizeof(float));allocated+=2*nf*ntr; F1p = (float *)calloc(2*nf*ntr,sizeof(float));allocated+=2*nf*ntr; /* The three flags of fft1 are: inv, sym, and opt */ fft1_init (nt, dt, ot, true, false); fft1_2D_fwd(F_arrival,MS,ntr); //sf_warning("passed fft? yes"); //fft1(F_arrival,MS,FF_arrival,0,0,1); /* memcpy(FA,2*nf*ntr*sizeof(float));*/ fprintf(stderr,"nt2 is %d\n",nt2); /* Output wavefields */ G = (float *)calloc(nt2*ntr,sizeof(float));allocated+=nt2*ntr; gp1= (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; gp= (float *)calloc(nt2*ntr,sizeof(float));allocated+=nt2*ntr; gm1= (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; gm= (float *)calloc(nt2*ntr,sizeof(float));allocated+=nt2*ntr; Gp= (float *)calloc(2*nf*ntr,sizeof(float));allocated+=nf*ntr; Gm= (float *)calloc(2*nf*ntr,sizeof(float));allocated+=nf*ntr; /* Time-reversal flag */ if (conj) { mode = -1; } else { mode = +1; } /* Load the reflection response into the memory */ if (verb) fprintf(stderr,"Before loading R %d\n",2*nf*ntr); Refl = (float *)calloc(2*nf*ntr*nshots,sizeof(float));allocated+=2*nf*ntr*nshots; /* Read REFL_000.rsf */ FRefl = sf_input("refl"); sf_warning("reading refl"); sf_floatread(Refl,2*nf*nshots*ntr,FRefl); sf_warning("read refl"); /* Build time-window */ tw = (int *)calloc(ntr,sizeof(int)); allocated+=ntr; window = (float *)calloc(nt*ntr,sizeof(float));allocated+=nt*ntr; /*memset(window,0,nt*ntr*sizeof(float));*/ /* I am not sure why I set it to this value */ /*for (ix=0; ix<ntr; ix++) { tw[ix] = nt*dt+ot+0.15; }*/ if (verb) fprintf(stderr,"---> Build time-window?\n"); // checking time sample corresponding to muting time for (ix=0; ix<ntr; ix++) { for (it=0; it<nt; it++) { if ((F_arrival[it+ix*nt]*F_arrival[it+ix*nt])>eps*eps) { /*tw[ix] = it*dt+ot;*/ tw[ix] = it; break; } } } if (verb) fprintf(stderr,"---> Build time-window1\n"); for (ix=0; ix<ntr; ix++) { twc = (int)(tw[ix]-shift-10); twa = (int)(-twc+nt); /*if (verb) fprintf(stderr,"%d %d\n",twc,twa);*/ for (it=0; it<nt; it++) { /* if ((it>twa) || (it<twc)) {*/ if ((it>twa) && (it<twc)) { window[it+ix*nt] = 1.0; // building windowing function W from Filippo's paper } } } if (verb) fprintf(stderr,"---> Build time-window2\n"); /* Smoothing of the window */ /* Should I implement flags for rect and iter? */ /* Look at Msmooth.c to understand below */ n[0] = nt; n[1] = ntr; s[0] = 1; s[1] = nt; rect[0] = 5; rect[1] = 5; for (ix=0; ix <= 1; ix++) { if (rect[ix] <= 1) continue; tr = sf_triangle_init (rect[ix],n[ix],false); for (it=0; it < (nt*ntr/n[ix]); it++) { i0 = sf_first_index (ix,it,1+1,n,s); for (iter=0; iter < 2; iter++) { sf_smooth2 (tr,i0,s[ix],false,window ); } } sf_triangle_close(tr); } if (verb) fprintf(stderr,"---> Here\n"); /* Tapering */ pi = 4.0*atan(1.0); taper = (float *)calloc(ntr,sizeof(float));allocated+=ntr; sf_warning("estimated memory: %f bytes",allocated*4.0f); memset(taper,0,ntr*sizeof(float)); for (ix=0; ix<tap; ix++) { taper[ix] = (float)(0.5*(1.0-cos(2.0*pi*(ix-0.0)/(2*tap)))); taper[ntr-ix-1] = taper[ix]; } for (ix=tap; ix<(ntr-tap); ix++) { taper[ix] = 1.0; } if (verb) fprintf(stderr,"---> taper finish\n"); FRefl = sf_input("refl"); /*------------------------------------------------------------*/ /* Loop over iterations */ /*------------------------------------------------------------*/ if (verb) fprintf(stderr,"---> Begin to iterative solve for f1p and f1m\n"); /*starting iteration for f1m */ memset(F1m_0,0,2*nf*ntr*sizeof(float)); for (ishot=0; ishot<nshots; ishot++) { /* Loop over receivers (traces) */ #ifdef _OPENMP #pragma omp parallel for private(ix,it,a,b,c,d) \ shared(MS,taper,Refl,F1m_0,MS2) #endif for (ix=0; ix<ntr; ix++) { /* Loop over frequencies */ #pragma ivdep for (it=0; it<2*nf; it=it+2) { /*(a + bi)(c + di) = (ac - bd) + (ad + bc)i*/ a = Refl[ix*2*nf+it+ishot*2*nf*ntr]*taper[ishot]; b = Refl[ix*2*nf+it+1+ishot*2*nf*ntr]*taper[ishot]; c = MS[ishot*2*nf+it]; d = MS[ishot*2*nf+it+1]; F1m_0[ix*2*nf+it] += (a*c - mode*b*d); F1m_0[ix*2*nf+it+1] += (mode*a*d + b*c); MS2 [ix*2*nf+it] += r*(a*c - b*d); // rTd* R MS2 [ix*2*nf+it+1] += r*(a*d + b*c); } /* End of loop over frequencies */ } /* End of loop over receivers (traces) */ } fft1_2D_inv (F1m_0, f1m_0,ntr); fft1_2D_inv (MS2, ms_2,ntr); #ifdef _OPENMP #pragma omp parallel for private(ix,it) \ shared(f1m, f1m_0, window,ms_2) #endif /* window to get f1m_0 */ for (ix=0; ix<ntr; ix++) { #pragma ivdep for (it=0; it<nt; it++) { f1m_0[it+ix*nt] = scale*window[it+ix*nt]*f1m_0[it+ix*nt]; ms_2[it+ix*nt] = scale*window[it+ix*nt]*ms_2[it+ix*nt]; //f1m_0[it+ix*nt] = scale*f1m_0[it+ix*nt]; f1m[it+ix*nt] = f1m_0[it+ix*nt]; } } fft1_2D_fwd(f1m,F1m,ntr); //fft1(f1m,F1m,FF_arrival,0,0,1); /* initialise MS the coda for f1+ */ memset(MS_0,0,2*nf*ntr*sizeof(float)); memset(MS,0,2*nf*ntr*sizeof(float)); for (ishot=0; ishot<nshots; ishot++) { /* Loop over receivers (traces) */ #ifdef _OPENMP #pragma omp parallel for private(ix,it,a,b,c,d) \ shared(MS_0,taper,Refl,F1m) #endif for (ix=0; ix<ntr; ix++) { /* Loop over frequencies */ #pragma ivdep for (it=0; it<2*nf; it=it+2) { /*(a + bi)(c + di) = (ac - bd) + (ad + bc)i*/ a = Refl[ix*2*nf+it+ishot*2*nf*ntr]*taper[ishot]; b = Refl[ix*2*nf+it+1+ishot*2*nf*ntr]*taper[ishot]; c = F1m[ishot*2*nf+it]; d = F1m[ishot*2*nf+it+1]; MS_0[ix*2*nf+it] += (a*c - mode*b*d); MS_0[ix*2*nf+it+1] += (mode*a*d + b*c); } /* End of loop over frequencies */ } /* End of loop over receivers (traces) */ } fft1_2D_inv(MS_0,ms_0,ntr); //fft1(MS_0,ms_0,FRefl,1,0,1); #ifdef _OPENMP #pragma omp parallel for private(ix,it) \ shared(ms, ms_0, window,ms_2) #endif /* window to get f1m_0 */ for (ix=0; ix<ntr; ix++) { #pragma ivdep for (it=0; it<nt; it++) { ms[it+ix*nt] =-ms_2[it+ix*nt] +scale*window[it+ix*nt]*ms_0[it+ix*nt]; //f1m_0[it+ix*nt] = scale*f1m_0[it+ix*nt]; //ms[it+ix*nt] = ms_0[it+ix*nt]; } } fft1_2D_fwd(ms,MS,ntr); if (verb) fprintf(stderr,"---> Beginning Iteration\n"); for (iter=0; iter<niter; iter++) { /* initialise MS1 and f1m1 the coda for f1+ */ memset(MS1,0,2*nf*ntr*sizeof(float)); memset(F1m1,0,2*nf*ntr*sizeof(float)); /*------------------------------------------------------------*/ /* Loop over shot positions */ /*------------------------------------------------------------*/ for (ishot=0; ishot<nshots; ishot++) { /* Loop over receivers (traces) */ #ifdef _OPENMP #pragma omp parallel for private(ix,it,a,b,c,d,e,f) \ shared(MS,taper,Refl,F1m,F1m1) #endif for (ix=0; ix<ntr; ix++) { /* Loop over frequencies */ #pragma ivdep for (it=0; it<2*nf; it=it+2) { /*(a + bi)(c + di) = (ac - bd) + (ad + bc)i*/ /*(a + bi)(e + fi) = (ae - bf) + (af + be)i*/ a = Refl[ix*2*nf+it+ishot*2*nf*ntr]*taper[ishot]; b = Refl[ix*2*nf+it+1+ishot*2*nf*ntr]*taper[ishot]; c = MS[ishot*2*nf+it]; d = MS[ishot*2*nf+it+1]; e = F1m[ishot*2*nf+it]; f = F1m[ishot*2*nf+it+1]; F1m1[ix*2*nf+it] += (a*c - mode*b*d) - r*(a*e - b*f); F1m1[ix*2*nf+it+1] += (mode*a*d + b*c) - r*(a*f + b*e); } /* End of loop over frequencies */ } /* End of loop over receivers (traces) */ } /* End of loop over shot positions */ /* Get time domain output of f1m and ms */ fft1_2D_inv(F1m1,f1m,ntr); #ifdef _OPENMP #pragma omp parallel for private(ix,it) \ shared(f1m, f1m_0, window) #endif for (ix=0; ix<ntr; ix++) { #pragma ivdep for (it=0; it<nt; it++) { f1m[it+ix*nt] = f1m_0[it+ix*nt] + scale*window[it+ix*nt]*(f1m[it+ix*nt]); } } fft1_2D_fwd(f1m,F1m,ntr); for (ishot=0; ishot<nshots; ishot++) { /* Loop over receivers (traces) */ #ifdef _OPENMP #pragma omp parallel for private(ix,it,a,b,c,d,e,f) \ shared(MS,MS1,taper,Refl,F1m) #endif for (ix=0; ix<ntr; ix++) { /* Loop over frequencies */ #pragma ivdep for (it=0; it<2*nf; it=it+2) { /*(a + bi)(c + di) = (ac - bd) + (ad + bc)i*/ /*(a + bi)(e + fi) = (ae - bf) + (af + be)i*/ a = Refl[ix*2*nf+it+ishot*2*nf*ntr]*taper[ishot]; b = Refl[ix*2*nf+it+1+ishot*2*nf*ntr]*taper[ishot]; c = MS[ishot*2*nf+it]; d = MS[ishot*2*nf+it+1]; e = F1m[ishot*2*nf+it]; f = F1m[ishot*2*nf+it+1]; MS1[ix*2*nf+it] += (a*e - mode*b*f) - r*(a*c - b*d); MS1[ix*2*nf+it+1] += (mode*a*f + b*e) - r*(a*d + b*c); } /* End of loop over frequencies */ } /* End of loop over receivers (traces) */ } /* End of loop over shot positions */ /* Get time domain output of f1m and ms */ fft1_2D_inv(MS1,ms,ntr); #ifdef _OPENMP #pragma omp parallel for private(ix,it) \ shared(ms, window) #endif for (ix=0; ix<ntr; ix++) { #pragma ivdep for (it=0; it<nt; it++) { ms[it+ix*nt] =-ms_2[it+ix*nt]+ scale*window[it+ix*nt]*(ms[it+ix*nt]); } } fft1_2D_fwd(ms,MS,ntr); if(iter%4==0) fprintf(stderr,"Iteration %d\n",iter); } /* End of loop over iterations */ /* Build f1p* by adding Tinv to coda M */ #ifdef _OPENMP #pragma omp parallel for private(ix,it) \ shared(f1pS,F_arrival,ms) #endif for (ix=0; ix<ntr; ix++) { #pragma ivdep for (it=0; it<nt; it++) { f1pS[it+ix*nt] = F_arrival[it+ix*nt] + ms[it+ix*nt]; /* note this is the time reverse version of f1p */ } } fft1_2D_fwd(f1pS,F1pS,ntr); /* to get G by looping over shots */ memset(Gp,0,2*nf*ntr*sizeof(float)); memset(Gm,0,2*nf*ntr*sizeof(float)); for (ishot=0; ishot<nshots; ishot++) { /* Loop over receivers (traces) */ #ifdef _OPENMP #pragma omp parallel for private(ix,it,a,b,c,d,e,f) \ shared(F1pS, F1m, taper, Refl, Gp, Gm) #endif for (ix=0; ix<ntr; ix++) { /* Loop over frequencies */ #pragma ivdep for (it=0; it<2*nf; it=it+2) { /*(a + bi)(c + di) = (ac - bd) + (ad + bc)i*/ a = Refl[ix*2*nf+it+ishot*2*nf*ntr]*taper[ishot]; b = Refl[ix*2*nf+it+1+ishot*2*nf*ntr]*taper[ishot]; c = F1pS[ishot*2*nf+it]; d = F1pS[ishot*2*nf+it+1]; e = F1m[ishot*2*nf+it]; f = F1m[ishot*2*nf+it+1]; Gm[ix*2*nf+it] += (a*c -mode* b*d) -r*(a*e - b*f); Gm[ix*2*nf+it+1] += (mode*a*d + b*c) -r*(a*f + b*e); Gp[ix*2*nf+it] += -(a*e - mode*b*f) + r*(a*c - b*d); Gp[ix*2*nf+it+1] += -(mode*a*f + b*e) + r*(a*d + b*c); } /* End of loop over frequencies */ } /* End of loop over receivers (traces) */ } fft1_2D_inv(Gp,gp1,ntr); fft1_2D_inv(Gp,gm1,ntr); if (Pf1) { if (verb) fprintf(stderr,"---> Build f1p\n"); for (ishot=0; ishot<nshots; ishot++) { /* Loop over receivers (traces) */ #ifdef _OPENMP #pragma omp parallel for private(ix,it,c,d) \ shared(F1pS, F1p) #endif #pragma ivdep for (it=0; it<2*nf; it=it+2) { /*(a + bi)(c + di) = (ac - bd) + (ad + bc)i*/ c = F1pS[ishot*2*nf+it]; d = F1pS[ishot*2*nf+it+1]; F1p[ishot*2*nf+it] = c; F1p[ishot*2*nf+it+1] = -d; } /* End of loop over frequencies */ } } fft1_2D_inv(F1p,f1p,ntr); if (verb) fprintf(stderr,"Build Gp, Gm and G\n"); #ifdef _OPENMP #pragma omp parallel for private(ix,it) \ shared(f1m, f1pS, gp, gm, gp1, gm1, G) #endif for (ix=0; ix<ntr; ix++) { #pragma ivdep for (it=0; it<nt2; it++) { gm[it+ix*nt2] = ((scale*gm1[it+nt2+ix*nt]) - f1m[ it+nt2+ix*nt])*(1.0 - window[it+nt2+ix*nt]); gp[it+ix*nt2] = ((scale*gp1[it+nt2+ix*nt]) + f1pS[it+nt2+ix*nt])*(1.0 - window[it+nt2+ix*nt]); G[ it+ix*nt2] = 0.5*(gp[it+ix*nt2] + gm[it+ix*nt2]); } } fprintf(stderr,"Build Gp, Gm and G\n"); /* Write the final result */ /*FRefl = sf_input(argv[1]);*/ /*fft1(Gp,,FRefl,1,0,0); fft1(Gm,,FRefl,1,0,0);*/ sf_floatwrite(gp,nt2*ntr,FGp); sf_fileclose(FGp); sf_floatwrite(gm,nt2*ntr,FGm); sf_fileclose(FGm); if (PG) { sf_floatwrite(G,nt2*ntr,FG); sf_fileclose(FG); } if (Pf1) { sf_floatwrite(f1p,nt*ntr,Ff1p); sf_fileclose(Ff1p); sf_floatwrite(f1m,nt*ntr,Ff1m); sf_fileclose(Ff1m); } if (twin) { sf_floatwrite(window,nt*ntr,Ftwin); sf_fileclose(Ftwin); } sf_fileclose(FRefl); sf_fileclose(FF_arrival); free(G); free(Gm); free(Gp); free(Refl); free(f1pS); free(F1pS); free(f1p); free(F1p); free(tw); free(filename1); free(MS); free(MS_0); free(MS1); free(MS2); free(F1m); free(F1m1); free(f1m_0); free(F1m_0); free(f1m); free(gp); free(gp1); free(gm); free(gm1); free(ms); free(ms_0); free(ms_2); free(F_arrival); free(window); exit (0); }