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_lop (bool adj, bool add, int nx, int ny, float* x, float* y)
/*< linear operator >*/
{
int i, j, i0;
if (nx != ny || nx != nd)
sf_error("%s: Wrong data dimensions: nx=%d, ny=%d, nd=%d",
__FILE__,nx,ny,nd);
sf_adjnull (adj,add,nx,ny,x,y);
if (adj) {
for (i=0; i < nd; i++) {
tmp[i] = y[i];
}
} else {
for (i=0; i < nd; i++) {
tmp[i] = x[i];
}
}
for (i=0; i < dim; i++) {
if (NULL != tr[i]) {
for (j=0; j < nd/n[i]; j++) {
i0 = sf_first_index (i,j,dim,n,s);
sf_smooth2 (tr[i], i0, s[i], false, tmp);
}
}
}
if (adj) {
for (i=0; i < nd; i++) {
x[i] += tmp[i];
}
} else {
for (i=0; i < nd; i++) {
y[i] += tmp[i];
}
}
}
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, nw[SF_MAX_DIM], s[SF_MAX_DIM], n[SF_MAX_DIM];
int i, j, iw, n1, n2, i0, i2;
float *data, *w[SF_MAX_DIM], wi;
char key[4];
sf_file in=NULL, out=NULL;
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,4,"nw%d",i+1);
if (!sf_getint(key,nw+i)) nw[i]=0;
/*( nw#=0 tapering on #-th axis )*/
if (nw[i] > 0) {
dim1 = i;
w[i] = sf_floatalloc(nw[i]);
for (iw=0; iw < nw[i]; iw++) {
wi = sinf(0.5*SF_PI*(iw+1.)/(nw[i]+1.));
w[i][iw] = wi*wi;
}
} else {
w[i] = NULL;
}
}
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);
for (i2=0; i2 < n2; i2++) {
sf_floatread(data,n1,in);
for (i=0; i <= dim1; i++) {
if (nw[i] <= 0) continue;
for (j=0; j < n1/n[i]; j++) {
i0 = sf_first_index (i,j,dim1+1,n,s);
for (iw=0; iw < nw[i]; iw++) {
wi = w[i][iw];
data[i0+iw*s[i]] *= wi;
data[i0+(n[i]-1-iw)*s[i]] *= wi;
}
}
}
sf_floatwrite(data,n1,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[])
{
int dim, dim1, i, j, k, rect[SF_MAX_DIM], s[SF_MAX_DIM], n[SF_MAX_DIM];
int nrep, irep, n1, n2, i2, i0, rmax;
char key[6];
float *data, *data2;
sf_file in=NULL, out=NULL;
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;
rmax = 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;
if (rect[i]+n[i] > rmax) rmax = rect[i]+n[i];
}
}
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);
data2 = sf_floatalloc (rmax);
if (!sf_getint("repeat",&nrep)) nrep=1;
/* repeat filtering several times */
for (i2=0; i2 < n2; i2++) {
sf_floatread(data,n1,in);
for (i=0; i <= dim1; i++) {
if (rect[i] <= 1) continue;
sf_box_init (rect[i],n[i],false);
for (j=0; j < n1/n[i]; j++) {
i0 = sf_first_index (i,j,dim1+1,n,s);
for (irep=0; irep < nrep; irep++) {
sf_boxsmooth2 (i0,s[i],data,data2);
for (k=0; k < n[i]; k++) {
data[i0+k*s[i]] = data2[k];
}
}
}
}
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);
}
