int main(int argc, char* argv[])
{
int nz,nx,ny,sou_z,sou_ox,sou_oy,sou_jx,sou_jy,sou_nx,sou_ny,rec_z,rec_nx,rec_ny,npad,noff,roll;
int dim1, dim2;
sf_axis ad1=NULL, ad2=NULL;
sf_file Fgeo=NULL;
int **geo=NULL;
sf_init(argc,argv);
if (!sf_getint("nz",&nz)) sf_error("Need nz="); /* dimension in z */
if (!sf_getint("nx",&nx)) sf_error("Need nx="); /* dimension in x */
if (!sf_getint("ny",&ny)) sf_error("Need ny="); /* dimension in y */
if (!sf_getint("sou_z", &sou_z )) sf_error("Need sou_z=" ); /* source position in depth */
if (!sf_getint("sou_ox",&sou_ox)) sf_error("Need sou_ox="); /* source starting location in x */
if (!sf_getint("sou_oy",&sou_oy)) sf_error("Need sou_oy="); /* source starting location in y */
if (!sf_getint("sou_nx",&sou_nx)) sf_error("Need sou_nx="); /* number of sources in x */
if (!sf_getint("sou_ny",&sou_ny)) sf_error("Need sou_ny="); /* number of sources in y */
if (!sf_getint("sou_jx",&sou_jx)) sou_jx = (sou_nx>1)? (nx-sou_ox)/(sou_nx-1):0; /* source interval in x */
if (!sf_getint("sou_jy",&sou_jy)) sou_jy = (sou_ny>1)? (ny-sou_oy)/(sou_ny-1):0; /* source interval in y */
if (!sf_getint("rec_z", &rec_z )) sf_error("Need rec_z=" ); /* receiver position in depth */
if (!sf_getint("rec_nx",&rec_nx)) sf_error("Need rec_nx="); /* number of receivers in x */
if (!sf_getint("rec_ny",&rec_ny)) sf_error("Need rec_ny="); /* number of receivers in y */
if (!sf_getint("npad",&npad)) sf_error("Need npad="); /* computational domain padding */
if (!sf_getint("noff",&noff)) sf_error("Need noff="); /* near offset */
if (!sf_getint("roll",&roll)) sf_error("Need roll="); /* acquisition pattern: 0-> fixed-spread, 1-> towed-streamer to the negative */
/* double check dimension */
if (sou_nx > (nx-sou_ox)/sou_jx+1) {
sou_nx = (nx-sou_ox)/sou_jx+1;
sf_warning("Setting sou_nx to %d",sou_nx);
}
if (sou_ny > 1 && sou_ny > (ny-sou_oy)/sou_jy+1) {
sou_ny = (ny-sou_oy)/sou_jy+1;
sf_warning("Setting sou_ny to %d",sou_ny);
}
/* do the work */
dim1 = 14;
dim2 = sou_nx*sou_ny;
ad1 = sf_maxa(dim1,0,1); sf_setlabel(ad1,"acqpar"); sf_raxa(ad1);
ad2 = sf_maxa(dim2,0,1); sf_setlabel(ad2,"shot"); sf_raxa(ad2);
Fgeo = sf_output("out");
sf_settype(Fgeo,SF_INT);
sf_oaxa(Fgeo,ad1,1);
sf_oaxa(Fgeo,ad2,2);
geo = sf_intalloc2(dim1,dim2);
geogen(geo,nz,nx,ny,sou_z,sou_ox,sou_oy,sou_jx,sou_jy,sou_nx,sou_ny,rec_z,rec_nx,rec_ny,npad,noff,roll);
sf_intwrite(geo[0],dim1*dim2,Fgeo);
exit(0);
}
void tomo2_init (float*** rays, int *raylen, int nrays,
float o1, float o2, float d1, float d2,
int n1, int n2,
interpolator interp, int nf_in)
{
int ir, id, i1, i2, nd;
float x1, x2, rx;
nf = nf_in;
m1 = n1;
m2 = n2;
nr = nrays;
rl = raylen;
nxy = (int***) sf_alloc(nr,sizeof(int**));
mask = (bool**) sf_alloc(nr,sizeof(bool*));
w1 = (float***) sf_alloc(nr,sizeof(float**));
w2 = (float***) sf_alloc(nr,sizeof(float**));
for (ir = 0; ir < nr; ir++) {
nd = rl[ir];
nxy[ir] = sf_intalloc2(2,nd);
mask[ir] = sf_boolalloc(nd);
w1[ir] = sf_floatalloc2(nf,nd);
w2[ir] = sf_floatalloc2(nf,nd);
for (id = 0; id < nd; id++) {
rx = (rays[ir][id][0] - o1)/d1;
i1 = (int) floor(rx + 1. - 0.5*nf);
x1 = rx - floor(rx);
rx = (rays[ir][id][1] - o2)/d2;
i2 = (int) floor(rx + 1. - 0.5*nf);
x2 = rx - floor(rx);
if (i1 > - nf && i1 < n1 &&
i2 > - nf && i2 < n2) {
mask[ir][id] = false;
interp (x1, nf, w1[ir][id]);
interp (x2, nf, w2[ir][id]);
nxy[ir][id][0] = i1;
nxy[ir][id][1] = i2;
} else {
mask[ir][id] = true;
}
}
}
}
void fastmarch_init(int *n1 /* grid samples [3] */,
float *o1 /* grid origin [3] */,
float *d1 /* grid sampling [3] */,
int order1 /* accuracy order */)
/*< initialize model dimensions and upwind order >*/
{
int its, mts;
int maxband;
#ifdef _OPENMP
mts = omp_get_max_threads();
#else
mts = 1;
#endif
/* model dimensions */
n = n1; order = order1; o = o1; d = d1;
s[0] = 1; s[1] = n[0]; s[2] = n[0]*n[1];
/* allocate shared memory */
in = sf_intalloc2(n[0]*n[1]*n[2],mts);
x = (float ***) sf_alloc(mts,sizeof (float **));
xn = (float ***) sf_alloc(mts,sizeof (float **));
x1 = (float ***) sf_alloc(mts,sizeof (float **));
offsets = (int **) sf_alloc(mts,sizeof (int *));
t = (float **) sf_alloc(mts,sizeof (float *));
maxband = 0;
if (n[0] > 1) maxband += 2*n[1]*n[2];
if (n[1] > 1) maxband += 2*n[0]*n[2];
if (n[2] > 1) maxband += 2*n[0]*n[1];
for (its=0; its < mts; its++) {
x[its] = (float **) sf_alloc ((10*maxband+1),sizeof (float *));
offsets[its] = (int *) sf_alloc (n[0]*n[1]*n[2],sizeof (int));
}
}
int main(int argc, char* argv[])
{
int n2, n3, i2, i3, is, **known=NULL;
float *chance=NULL, perc;
sf_file in=NULL, mask=NULL;
sf_init(argc,argv);
in = sf_input("in");
mask = sf_output("out");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&n3)) sf_error("No n3= in input");
sf_putint(mask,"n1",n2);
sf_putint(mask,"n2",n3);
sf_putint(mask,"n3",1);
sf_settype(mask,SF_INT);
if (!sf_getfloat("perc",&perc)) perc=0.75;
/* how many shots to remove */
known = sf_intalloc2(n2,n3);
chance = sf_floatalloc(n2+n3);
init_genrand(2003);
sf_random (n2+n3,chance);
for (i3=0; i3 < n3; i3++) { /* half-offset */
for (i2=0; i2 < n2; i2++) { /* midpoint */
is = i2 - i3 + n3-1; /* shot */
known[i3][i2] = (chance[is] > perc);
}
}
sf_intwrite (known[0],n2*n3,mask);
exit(0);
}
int main(int argc, char* argv[])
{
int n1, n2, ns, nw;
int is, iw, **pp, i, ip;
double omega;
float dw, ow;
float *ahess, **ahesss, **ahessr;
sf_complex **f, ***swave, ***rwave;
sf_complex **stemp, **rtemp;
sf_file in, out, list, us, ur, wvlt;
int uts, mts;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_getint("uts",&uts)) uts=0;
/* number of OMP threads */
#ifdef _OPENMP
mts = omp_get_max_threads();
#else
mts = 1;
#endif
uts = (uts < 1)? mts: uts;
/* read model dimensions */
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input.");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input.");
/* read source wavefield */
if (NULL == sf_getstring("us"))
sf_error("Need source wavefield us=");
us = sf_input("us");
if (!sf_histint(us,"n3",&ns)) sf_error("No ns=.");
if (!sf_histint(us,"n4",&nw)) sf_error("No nw=.");
if (!sf_histfloat(us,"d4",&dw)) sf_error("No dw=.");
if (!sf_histfloat(us,"o4",&ow)) sf_error("No ow=.");
/* read receiver wavefield */
if (NULL == sf_getstring("ur"))
sf_error("Need receiver wavefield ur=");
ur = sf_input("ur");
/* read wavelet */
if (NULL == sf_getstring("wvlt"))
sf_error("Need wvlt=");
wvlt = sf_input("wvlt");
f = sf_complexalloc2(nw,ns);
sf_complexread(f[0],nw*ns,wvlt);
sf_fileclose(wvlt);
/* read list */
if (NULL == sf_getstring("list"))
sf_error("Need list=");
list = sf_input("list");
pp = sf_intalloc2(2,ns);
sf_intread(pp[0],2*ns,list);
sf_fileclose(list);
/* allocate memory */
swave = sf_complexalloc3(n1,n2,ns);
rwave = sf_complexalloc3(n1,n2,ns);
stemp = sf_complexalloc2(ns,ns);
rtemp = sf_complexalloc2(ns,ns);
ahesss = sf_floatalloc2(n1*n2,ns);
ahessr = sf_floatalloc2(n1*n2,ns);
ahess = sf_floatalloc(n1*n2);
/* loop over frequency */
for (iw=0; iw < nw; iw++) {
omega = (double) 2.*SF_PI*(ow+iw*dw);
/* read wavefields */
sf_complexread(swave[0][0],n1*n2*ns,us);
sf_complexread(rwave[0][0],n1*n2*ns,ur);
#ifdef _OPENMP
#pragma omp parallel num_threads(uts) private(is,ip,i)
#endif
{
#ifdef _OPENMP
#pragma omp for
#endif
for (is=0; is < ns; is++) {
for (ip=0; ip < ns; ip++) {
/* temps */
stemp[is][ip] = -omega*omega/conjf(f[ip][iw])
*rwave[is][pp[ip][1]][pp[ip][0]];
/* tempr */
rtemp[is][ip] = -omega*omega/conjf(f[ip][iw])
*conjf(swave[is][pp[ip][1]][pp[ip][0]]);
}
}
/* loop over model */
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i < n1*n2; i++) {
for (is=0; is < ns; is++) {
for (ip=0; ip < ns; ip++) {
ahesss[ip][i] += crealf(
conjf(swave[ip][0][i]*swave[is][0][i])*stemp[is][ip]);
ahessr[ip][i] += crealf(
conjf(swave[ip][0][i])*rwave[is][0][i]*rtemp[is][ip]);
}
}
}
}
}
/* assemble */
#ifdef _OPENMP
#pragma omp parallel for num_threads(uts) private(i,ip)
#endif
for (i=0; i < n1*n2; i++) {
for (ip=0; ip < ns; ip++) {
ahess[i] += powf(ahesss[ip][i]+ahessr[ip][i],2.);
}
}
/* output hessian */
sf_floatwrite(ahess,n1*n2,out);
exit(0);
}
surface kirmodnewton2_init(int ns, float s0, float ds /* source/midpoint axis */,
int nh, float h0, float dh /* offset axis */,
int nx1, float x01, float dx1 /* reflector axis */,
int nc1 /* number of reflectors */,
bool cmp /* if CMP instead of shot gather */,
bool absoff /* use absolute offset */)
/*< Initialize surface locations same as in kirmod2 >*/
{
int is, ih, iy;
float s, h;
surface yi, y;
nx = nx1;
dx = dx1;
x0 = x01;
nc = nc1;
if (cmp) {
ny = 2*ns*nh;
map = sf_intalloc2(2*nh,ns);
} else {
ny = ns*(nh+1);
map = sf_intalloc2(nh+1,ns);
}
y = (surface) sf_alloc(ny,sizeof(*y));
yi = y;
for (is=0; is < ns; is++) {
s = s0 + is*ds;
if (cmp) {
for (ih=0; ih < nh; ih++, yi++) {
h = 0.5*(h0 + ih*dh);
yi->x = s - h;
yi->is = is;
yi->ih = 2*ih;
yi++;
yi->x = s + h;
yi->is = is;
yi->ih = 2*ih+1;
}
} else {
for (ih=0; ih < nh; ih++, yi++) {
yi->x = absoff ? h0 + ih*dh : s + h0 + ih*dh;
yi->is = is;
yi->ih = ih;
}
yi->x = s;
yi->is = is;
yi->ih = nh;
yi++;
}
}
qsort(y,ny,sizeof(*y),surface_comp);
for (iy=0; iy < ny; iy++) {
yi = y+iy;
map[yi->is][yi->ih] = iy;
}
return y;
}
/*------------------------------------------------------------*/
wexcip3d wexcip_init(wexcub3d cub,
int nhx_,
int nhy_,
int nhz_,
int nht_,
int nhx2_,
int nhy2_,
int nhz2_,
int nht2_,
int nc_,
float dht_,
float oht_,
sf_file Fc,
int eic)
/*< initialize I.C. >*/
{
int iw, ic, ihx, ihy, ihz, iht, icx, icy, icz;
float ht, w;
/*------------------------------------------------------------*/
wexcip3d cip;
cip = (wexcip3d) sf_alloc(1,sizeof(*cip));
/*------------------------------------------------------------*/
/* allocate wavefields storage */
cip->ws = sf_complexalloc3(cub->amx.n,cub->amy.n,cub->az.n);
cip->wr = sf_complexalloc3(cub->amx.n,cub->amy.n,cub->az.n);
cip->ci = sf_complexalloc3(cub->amx.n,cub->amy.n,cub->az.n);
if(eic) {
cip->nhx = nhx_;
cip->nhy = nhy_;
cip->nhz = nhz_;
cip->nht = nht_;
cip->nhx2= nhx2_;
cip->nhy2= nhy2_;
cip->nhz2= nhz2_;
cip->nht2= nht2_;
cip->nc = nc_;
cip->oht = oht_;
cip->dht = dht_;
/*------------------------------------------------------------*/
/* precompute phase for time delay */
cip->tt = sf_complexalloc2(cip->nht2,cub->aw.n);
for(iw=0; iw<cub->aw.n; iw++) {
w = -( cub->aw.o+iw*cub->aw.d );
for(iht=0; iht<cip->nht2; iht++) {
ht = cip->oht + (iht+0)*cip->dht;
cip->tt[iw][iht] = sf_cmplx(cosf(2*w*ht),sinf(2*w*ht));
}
}
/*------------------------------------------------------------*/
/* allocate image storage */
cip->ei = sf_complexalloc5(cip->nhx2,cip->nhy2,cip->nhz2,cip->nht2,cip->nc);
cip->di = sf_complexalloc5(cip->nhx2,cip->nhy2,cip->nhz2,cip->nht2,cip->nc);
for(ic=0; ic<cip->nc; ic++) {
for(iht=0; iht<cip->nht2; iht++) {
for(ihz=0; ihz<cip->nhz2; ihz++) {
for(ihy=0; ihy<cip->nhy2; ihy++) {
for(ihx=0; ihx<cip->nhx2; ihx++) {
cip->ei[ic][iht][ihz][ihy][ihx] = sf_cmplx(0.0,0.0);
cip->di[ic][iht][ihz][ihy][ihx] = sf_cmplx(0.0,0.0);
}
}
}
}
}
/*------------------------------------------------------------*/
/* CIP coordinates */
cip->cc= (pt3d*) sf_alloc(cip->nc,sizeof(*cip->cc));
pt3dread1(Fc,cip->cc,cip->nc,3); /* read coordinates */
cip->mcxall=sf_intalloc2(cip->nhx2,cip->nc);
cip->pcxall=sf_intalloc2(cip->nhx2,cip->nc);
cip->mcyall=sf_intalloc2(cip->nhy2,cip->nc);
cip->pcyall=sf_intalloc2(cip->nhy2,cip->nc);
cip->mczall=sf_intalloc2(cip->nhz2,cip->nc);
cip->pczall=sf_intalloc2(cip->nhz2,cip->nc);
cip->ccin=sf_intalloc(cip->nc);
cip->cxmin = cub->amx.o + cip->nhx *cub->amx.d;
cip->cxmax = cub->amx.o + (cub->amx.n-1-cip->nhx)*cub->amx.d;
cip->cymin = cub->amy.o + cip->nhy *cub->amy.d;
cip->cymax = cub->amy.o + (cub->amy.n-1-cip->nhy)*cub->amy.d;
cip->czmin = cub->az.o + cip->nhz *cub->az.d;
cip->czmax = cub->az.o + (cub->az.n -1-cip->nhz)*cub->az.d;
for(ic=0; ic<cip->nc; ic++) {
cip->ccin[ic]=(cip->cc[ic].x>=cip->cxmin && cip->cc[ic].x<=cip->cxmax &&
cip->cc[ic].y>=cip->cymin && cip->cc[ic].y<=cip->cymax &&
cip->cc[ic].z>=cip->czmin && cip->cc[ic].z<=cip->czmax)?1:0;
if(cip->ccin[ic]) {
icx = 0.5+(cip->cc[ic].x-cub->amx.o)/cub->amx.d;
for(ihx=-cip->nhx; ihx<cip->nhx+1; ihx++) {
cip->mcxall[ic][cip->nhx+ihx] = icx-ihx;
cip->pcxall[ic][cip->nhx+ihx] = icx+ihx;
}
icy = 0.5+(cip->cc[ic].y-cub->amy.o)/cub->amy.d;
for(ihy=-cip->nhy; ihy<cip->nhy+1; ihy++) {
cip->mcyall[ic][cip->nhy+ihy] = icy-ihy;
cip->pcyall[ic][cip->nhy+ihy] = icy+ihy;
}
icz = 0.5+(cip->cc[ic].z-cub->az.o)/cub->az.d;
for(ihz=-cip->nhz; ihz<cip->nhz+1; ihz++) {
cip->mczall[ic][cip->nhz+ihz] = icz-ihz;
cip->pczall[ic][cip->nhz+ihz] = icz+ihz;
}
for(ihx=-cip->nhx; ihx<cip->nhx+1; ihx++) {
for(ihy=-cip->nhy; ihy<cip->nhy+1; ihy++) {
for(ihz=-cip->nhz; ihz<cip->nhz+1; ihz++) {
// sf_warning("ihx=%d,ihy=%d,ihz=%d,mcx=%d,pcx=%d,mcy=%d,pcy=%d,mcz=%d,pcz=%d",ihx,ihy,ihz,cip->mcxall[ic][cip->nhx+ihx],cip->pcxall[ic][cip->nhx+ihx],cip->mcyall[ic][cip->nhy+ihy],cip->pcyall[ic][cip->nhy+ihy],cip->mczall[ic][cip->nhz+ihz],cip->pczall[ic][cip->nhz+ihz]);
}
}
}
}
} /* loop over nc */
}
return cip;
}
int main(int argc, char* argv[])
{
int verbose;
int i, i1, n1_headers, n1_traces, len, tempint, outkeyindx;
sf_file in, out;
char *output=NULL, *outputkey=NULL;
float /* *ftra=NULL, */ **fbuf=NULL, **fst=NULL;
int /* *itra=NULL, */ **ibuf=NULL, **ist=NULL;
char* header_format;
sf_datatype typehead;
float* fheader=NULL;
int* iheader=NULL;
float* intrace=NULL;
sf_init (argc,argv);
/*****************************/
/* initialize verbose switch */
/*****************************/
if(!sf_getint("verbose",&verbose))verbose=1;
/* \n
flag to control amount of print
0 terse, 1 informative, 2 chatty, 3 debug
*/
sf_warning("verbose=%d",verbose);
/******************************************/
/* input and output data are stdin/stdout */
/******************************************/
in = sf_input ("in");
out = sf_output ("out");
if (!sf_histint(in,"n1_traces",&n1_traces))
sf_error("input data not define n1_traces");
if (!sf_histint(in,"n1_headers",&n1_headers))
sf_error("input data does not define n1_headers");
/* kls change type to header_format and read from history */
header_format=sf_histstring(in,"header_format");
if(strcmp (header_format,"native_int")==0) typehead=SF_INT;
else typehead=SF_FLOAT;
if(verbose>0)fprintf(stderr,"allocate headers. n1_headers=%d\n",n1_headers);
fheader = sf_floatalloc(n1_headers);
iheader = (int*)fheader;
if(verbose>0)fprintf(stderr,"allocate intrace. n1_traces=%d\n",n1_traces);
intrace= sf_floatalloc(n1_traces);
segy_init(n1_headers,in);
for (i=0; i < n1_headers; i++) {
/* see if the segy keywords are in the input history file. If they
are missing or different than I think they should be add them to
the output file history */
/* no idea why this always has to be added to history, but I get
errors it I remove the forcing condition below (i.e. 1 || ) */
if(1 || !sf_histint(in,segykeyword(i),&tempint) || tempint!=i){
sf_putint(out,segykeyword(i),i);
}
}
if (NULL == (output = sf_getstring("output"))) sf_error("Need output=");
/* Describes the output in a mathematical notation. */
len = sf_math_parse (output,out,typehead);
if (NULL==(outputkey=sf_getstring("outputkey")))sf_error("Need outputkey=");
/* name of the header key to put the results of the output equation */
if(!sf_histint(out,outputkey,&outkeyindx)){
sf_error("user parameter outputkey is not an input data header key.");
}
if(verbose>0)fprintf(stderr,"outkeyindx=%d\n",outkeyindx);
/* I do not like these 2d arrays with one of the lengths is 1.
I have done this so I can continue to use sf_math_parse and
sf_math_evaluate. Perhaps someday these can be refactored and the
alloc2 below can become sf_floatalloc (without the 2). Karl S */
if (SF_FLOAT == typehead) { /* float typehead */
/* ftra = sf_floatalloc(n1_headers); */
fbuf = sf_floatalloc2(1,n1_headers);
fst = sf_floatalloc2(1,len+3);
} else { /* int typehead */
/* itra = sf_intalloc(n1_headers); */
ibuf = sf_intalloc2(1,n1_headers);
ist = sf_intalloc2(1,len+3);
}
/* put the history from the input file to the output */
sf_fileflush(out,in);
/***************************/
/* start trace loop */
/***************************/
if(verbose>0)fprintf(stderr,"start trace loop\n");
while (0==get_tah(intrace, fheader, n1_traces, n1_headers, in)){
if(verbose>1)fprintf(stderr,"process the tah in sftahgethw\n");
/********************/
/* process the tah. */
/********************/
if (SF_FLOAT == typehead) {
for (i1=0; i1 < n1_headers; i1++) {
fbuf[i1][0]=fheader[i1];
}
sf_math_evaluate (len, 1, fbuf, fst);
if(verbose>2){
fprintf(stderr,"after math_evaluate fst[1][0]=%f\n",fst[1][0]);
}
fheader[outkeyindx]=fst[1][0];
} else {
for (i1=0; i1 < n1_headers; i1++) {
/* iheader point to same place as fheader */
ibuf[i1][0]=iheader[i1];
if(verbose>2)fprintf(stderr,"iheader[i1]=%d\n",iheader[i1]);
}
sf_int_math_evaluate (len, 1, ibuf, ist);
if(verbose>2){
fprintf(stderr,"after int_math_evaluate ist[1][0]=%d\n",ist[1][0]);
}
iheader[outkeyindx]=ist[1][0];
}
/***************************/
/* write trace and headers */
/***************************/
put_tah(intrace, fheader, n1_traces, n1_headers, out);
if(verbose>1)fprintf(stderr,"returned from writing the tah\n");
}
exit(0);
}
int main(int argc, char* argv[])
{
int n1, n2, n3, i1, i2, i3, j1, j2, k1, k2, nedge, nold, nmin, nmax, n12;
int **edge;
float **pp, **ww, **w1, **w2, g1, g2, w, min, max;
sf_file in=NULL, out=NULL;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n3 = sf_leftsize(in,2);
if (!sf_getfloat("min",&min)) min=5.0;
/* minimum threshold */
if (!sf_getfloat("max",&max)) max=95.0;
/* maximum threshold */
n12 = n1*n2;
nmin = min*0.01*n12;
if (nmin < 0) nmin=0;
if (nmin >= n12) nmin=n12-1;
nmax = max*0.01*n12;
if (nmax < 0) nmax=0;
if (nmax >= n12) nmax=n12-1;
pp = sf_floatalloc2(n1,n2);
w1 = sf_floatalloc2(n1,n2);
w2 = sf_floatalloc2(n1,n2);
ww = sf_floatalloc2(n1,n2);
edge = sf_intalloc2(n1,n2);
sf_settype(out,SF_INT);
for (i3=0; i3 < n3; i3++) {
sf_floatread(pp[0],n12,in);
/* gradient computation */
sf_sobel(n1,n2,pp,w1,w2);
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
/* gradient norm */
g1 = w1[i2][i1];
g2 = w2[i2][i1];
ww[i2][i1] = g1*g1+g2*g2;
}
}
/* edge thinning */
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
g1 = w1[i2][i1];
g2 = w2[i2][i1];
if (fabsf(g1) > fabsf(g2)) {
j1=1;
if (g2/g1 > 0.5) {
j2=1;
} else if (g2/g1 < - 0.5) {
j2=-1;
} else {
j2=0;
}
} else if (fabsf(g2) > fabsf(g1)) {
j2=1;
if (g1/g2 > 0.5) {
j1=1;
} else if (g1/g2 < - 0.5) {
j1=-1;
} else {
j1=0;
}
} else {
j1=0;
j2=0;
}
k1 = i1+j1; if (j1 && (k1 < 0 || k1 >= n1)) k1=i1;
k2 = i2+j2; if (j2 && (k2 < 0 || k2 >= n2)) k2=i2;
if (ww[i2][i1] <= ww[k2][k1]) {
pp[i2][i1] = 0.;
continue;
}
k1 = i1-j1; if (k1 < 0 || k1 >= n1) k1=i1;
k2 = i2-j2; if (k2 < 0 || k2 >= n2) k2=i2;
if (ww[i2][i1] <= ww[k2][k1]) {
pp[i2][i1] = 0.;
continue;
}
pp[i2][i1] = ww[i2][i1];
}
}
/* edge selection */
max = sf_quantile(nmax,n12,ww[0]);
min = sf_quantile(nmin,n12,ww[0]);
nedge=0;
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
w = pp[i2][i1];
if (w > max) {
edge[i2][i1] = SF_IN;
nedge++;
} else if (w < min) {
edge[i2][i1] = SF_OUT;
} else {
edge[i2][i1] = SF_FRONT;
}
}
}
nold=0;
while (nedge != nold) {
nold = nedge;
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
if (SF_FRONT == edge[i2][i1]) {
if (i2 > 0) {
if (SF_IN == edge[i2-1][i1] ||
(i1 > 0 && SF_IN == edge[i2-1][i1-1]) ||
(i1 < n1-1 && SF_IN == edge[i2-1][i1+1])) {
edge[i2][i1] = SF_IN;
nedge++;
continue;
}
}
if (i2 < n2-1) {
if (SF_IN == edge[i2+1][i1] ||
(i1 > 0 && SF_IN == edge[i2+1][i1-1]) ||
(i1 < n1-1 && SF_IN == edge[i2+1][i1+1])) {
edge[i2][i1] = SF_IN;
nedge++;
continue;
}
}
if ((i1 > 0 && SF_IN == edge[i2][i1-1]) ||
(i1 < n1-1 && SF_IN == edge[i2][i1+1])) {
edge[i2][i1] = SF_IN;
nedge++;
continue;
}
}
}
}
}
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
if (SF_FRONT == edge[i2][i1]) edge[i2][i1] = SF_OUT;
}
}
sf_intwrite(edge[0],n12,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
bool segy;
int i, i1, i2, n1, n2, n3, n, nt, len, nkey, row;
sf_file in, out;
int mem; /* for avoiding int to off_t typecast warning */
off_t memsize;
char *eq, *output, *key, *arg;
float **ftra=NULL, **fbuf=NULL, **fst=NULL, d2, o2;
int **itra=NULL, **ibuf=NULL, **ist=NULL;
sf_datatype type;
sf_init (argc,argv);
in = sf_input ("in");
out = sf_output ("out");
sf_putint(out,"N",0);
sf_putint(out,"T",1);
sf_putint(out,"input",2);
type = sf_gettype(in);
if (SF_FLOAT != type && SF_INT != type) sf_error("Need float or int input");
if (!sf_getbool("segy",&segy)) segy=true;
/* if SEGY headers */
if (!sf_histint(in,"n1",&n1)) n1=1;
if (!sf_histint(in,"n2",&n2)) n2=1;
n3 = sf_leftsize(in,2); /* left dimensions after the first two */
if (segy) {
segy_init(n1,in);
} else {
other_init(n1,in);
}
if (NULL != (key = sf_getstring("key"))) {
/* key to replace */
row = segykey(key);
free(key);
} else {
if (!sf_getint("nkey",&row)) row=-1;
/* number of key to replace */
}
if (row > n1) sf_error("nkey=%d is too large, need nkey <= %d",row,n1);
if (n1 > 1) {
if (n2 > 1) { /* input: many keys */
if (row < 0) sf_putint(out,"n1",1);
} else { /* input: one key, arranged in n1 */
n2 = n1;
n1 = 1;
}
}
for (i=0; i < n1; i++) {
sf_putint(out,segykeyword(i),i+3);
}
for (i=1; i< argc; i++) { /* collect inputs */
arg = argv[i];
eq = strchr(arg,'=');
if (NULL == eq) continue; /* not a parameter */
if (0 == strncmp(arg,"output",6) ||
0 == strncmp(arg, "--",2)) continue; /* not a key */
len = (size_t) (eq-arg);
key = sf_charalloc(len+1);
memcpy(key,arg,len);
key[len]='\0';
if (sf_getint(key,&nkey))
sf_putint(out,key,nkey+3);
free(key);
}
if (!sf_histfloat(in,n1>1? "d2":"d1",&d2)) d2=1.;
if (!sf_histfloat(in,n1>1? "o2":"o1",&o2)) o2=0.;
if (NULL == (output = sf_getstring("output"))) sf_error("Need output=");
/* Describes the output in a mathematical notation. */
if (!sf_getint("memsize",&mem))
mem=sf_memsize();
/* Max amount of RAM (in Mb) to be used */
memsize = mem * (1<<20); /* convert Mb to bytes */
len = sf_math_parse (output,out,type);
/* number of traces for optimal I/O */
nt = SF_MAX(1,memsize/((2*n1+len+6)*sizeof(float)));
if (SF_FLOAT == type) { /* float type */
ftra = sf_floatalloc2(n1,nt);
fbuf = sf_floatalloc2(nt,n1+3);
fst = sf_floatalloc2(nt,len+3);
} else { /* int type */
itra = sf_intalloc2(n1,nt);
ibuf = sf_intalloc2(nt,n1+3);
ist = sf_intalloc2(nt,len+3);
}
for (n=n2*n3; n > 0; n -= nt) {
if (n < nt) nt=n;
if (SF_FLOAT == type) {
sf_floatread(ftra[0],n1*nt,in);
} else {
sf_intread(itra[0],n1*nt,in);
}
for (i2=0; i2 < nt; i2++) {
if (SF_FLOAT == type) {
fbuf[0][i2]=(float) i2; /* N */
fbuf[1][i2]=o2+i2*d2; /* T */
fbuf[2][i2]=ftra[0][i2]; /* input */
} else {
ibuf[0][i2]=i2; /* N */
ibuf[1][i2]=o2+i2*d2; /* T */
ibuf[2][i2]=itra[0][i2]; /* input */
}
}
for (i1=0; i1 < n1; i1++) {
for (i2=0; i2 < nt; i2++) {
if (SF_FLOAT == type) {
fbuf[i1+3][i2]=ftra[i2][i1];
} else {
ibuf[i1+3][i2]=itra[i2][i1];
}
}
}
if (SF_FLOAT == type) {
sf_math_evaluate (len, nt, fbuf, fst);
if (row < 0) {
sf_floatwrite(fst[1],nt,out);
} else {
for (i2=0; i2 < nt; i2++) {
ftra[i2][row] = fst[1][i2];
}
sf_floatwrite(ftra[0],n1*nt,out);
}
} else {
sf_int_math_evaluate (len, nt, ibuf, ist);
if (row < 0) {
sf_intwrite(ist[1],nt,out);
} else {
for (i2=0; i2 < nt; i2++) {
itra[i2][row] = ist[1][i2];
}
sf_intwrite(itra[0],n1*nt,out);
}
}
}
exit(0);
}
void interpfield_(float ***oldf, float ***newf, bool extend,
int on1, float oo1, float od1, /* old */
int on2, float oo2, float od2,
int on3, float oo3, float od3,
int nn1, float no1, float nd1, /* new */
int nn2, float no2, float nd2,
int nn3, float no3, float nd3)
{
float *x1 = sf_floatalloc(nn1);
float *x2 = sf_floatalloc(nn2);
float *x3 = sf_floatalloc(nn3);
int b1 = nn1;
int b2 = nn2;
int b3 = nn3;
int e1 = 0;
int e2 = 0;
int e3 = 0;
int ns = gs_ns;
memset(newf[0][0], 0, sizeof(float)*nn1*nn2*nn3);
x_b_e(on1, oo1, od1, nn1, no1, nd1, x1, &b1, &e1);
x_b_e(on2, oo2, od2, nn2, no2, nd2, x2, &b2, &e2);
x_b_e(on3, oo3, od3, nn3, no3, nd3, x3, &b3, &e3);
/*sf_warning("b1,b2,b3: %d, %d, %d", b1, b2, b3);*/
/*sf_warning("e1,e2,e3: %d, %d, %d", e1, e2, e3);*/
/*for (int i = 0; i < nn3; i++) {*/
/*sf_warning("%f", x3[i]);*/
/*}*/
int *k1 = sf_intalloc(nn1); assert(k1);
int *k2 = sf_intalloc(nn2);
int *k3 = sf_intalloc(nn3);
int *t1 = sf_intalloc(nn1);
int *t2 = sf_intalloc(nn2);
int *t3 = sf_intalloc(nn3);
int **c1 = sf_intalloc2(ns, nn1);
int **c2 = sf_intalloc2(ns, nn2);
int **c3 = sf_intalloc2(ns, nn3);
calc_t(x1, k1, t1, nn1, gs_npts);
calc_t(x2, k2, t2, nn2, gs_npts);
calc_t(x3, k3, t3, nn3, gs_npts);
up_clip(t1, nn1, gs_npts - 1);
up_clip(t2, nn2, gs_npts - 1);
up_clip(t3, nn3, gs_npts - 1);
/*sf_warning("sumk1, sumk2, sumk3: %d, %d, %d", isum1(k1,nn1), isum1(k2,nn2), isum1(k3, nn3));*/
/*sf_warning("sumt1, sumt2, sumt3: %d, %d, %d", isum1(t1,nn1), isum1(t2,nn2), isum1(t3, nn3));*/
for (int is = 0; is < ns; is++) {
for (int i1 = 0; i1 < nn1; i1++) {
c1[i1][is] = k1[i1] - 4 + is;
}
for (int i2 = 0; i2 < nn2; i2++) {
c2[i2][is] = k2[i2] - 4 + is;
}
for (int i3 = 0; i3 < nn3; i3++) {
c3[i3][is] = k3[i3] - 4 + is;
}
}
updown_cip(c1, ns, nn1, 0, on1-1);
updown_cip(c2, ns, nn2, 0, on2-1);
updown_cip(c3, ns, nn3, 0, on3-1);
/*for (int i = 0; i < ns; i++) {*/
/*sf_warning("c1[0][%d]: %d", i, c1[0][i]);*/
/*}*/
/*sf_warning("write c1, c2, c3");*/
/*write2di("c1.rsf", c1, ns, nn1);*/
/*write2di("c2.rsf", c2, ns, nn2);*/
/*write2di("c3.rsf", c3, ns, nn3);*/
/*write1di("t1.rsf", t1, nn1);*/
/*exit(0);*/
if (extend) {
/*sf_warning("computation of interpolation with extend = true");*/
#ifdef _OPENMP
#pragma omp parallel for
#endif
for (int i3 = 0; i3 < nn3; i3++) {
for (int i2 = 0; i2 < nn2; i2++) {
for (int i1 = 0; i1 < nn1; i1++) {
for (int ic = 0; ic < ns; ic++) {
for (int ib = 0; ib < ns; ib++) {
for (int ia = 0; ia < ns; ia++) {
newf[i3][i2][i1] +=
oldf[c3[i3][ic]][c2[i2][ib]][c1[i1][ia]] *
gs_sinc_table[t1[i1]][ia] *
gs_sinc_table[t2[i2]][ib] *
gs_sinc_table[t3[i3]][ic];
}
}
}
}
}
}
} else {
/*sf_warning("computation of interpolation without extend");*/
#ifdef _OPENMP
#pragma omp parallel for
#endif
for (int i3 = b3; i3 <= e3; i3++) {
for (int i2 = b2; i2 <= e2; i2++) {
for (int i1 = b1; i1 <= e1; i1++) {
for (int ic = 0; ic < ns; ic++) {
for (int ib = 0; ib < ns; ib++) {
for (int ia = 0; ia < ns; ia++) {
newf[i3][i2][i1] +=
oldf[c3[i3][ic]][c2[i2][ib]][c1[i1][ia]] *
gs_sinc_table[t1[i1]][ia] *
gs_sinc_table[t2[i2]][ib] *
gs_sinc_table[t3[i3]][ic];
}
}
}
}
}
}
}
free(x1); free(x2); free(x3);
free(k1); free(k2); free(k3);
free(t1); free(t2); free(t3);
free(*c1); free(*c2); free(*c3);
free(c1); free(c2); free(c3);
}
/* 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 */
bool fm; /* forward modeling */
/*I/O*/
sf_file Fvel;
sf_file left, right, leftb, rightb;
sf_file Fsrc, Frcd/*source and record*/;
sf_file Ftmpwf;
sf_file Fimg;
sf_file mask;
/*axis*/
sf_axis at, ax, az, as;
/*grid index variables*/
int nx, nz, nt, wfnt;
int nzx, nx2, nz2, n2, m2, pad1, nk;
int ix, iz, it, is;
int nxb, nzb;
int snpint, wfint;
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 **kill=NULL;
int rectz,rectx,repeat; /*smoothing parameters*/
float trunc;
int sht0,shtbgn,shtend,shtnum,shtint;
/*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=true; /*if n, receiver is independent of source location and gpl=nx*/
if (!sf_getbool("fm", &fm)) fm=false; /* if n, Born modelling */
if (!sf_getbool("incom", &incom)) incom=false; /* if n, use complete data */
/* 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;
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 */
if (!sf_getint("wfint", &wfint)) wfint=50; /* snap interval */
/*--- parameters of source ---*/
if (!sf_getfloat("srctrunc", &trunc)) trunc=0.4;
if (!sf_getint("rectz", &rectz)) rectz=2;
if (!sf_getint("rectx", &rectx)) rectx=2;
if (!sf_getint("repeat", &repeat)) repeat=2;
/* 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;
/* simultaneous sources parameter */
if (!sf_getint("nsource", &nsource)) nsource=1;
if (!sf_getint("dsource", &dsource)) dsource=0;
if (!sf_getfloat("tdelay", &tdelay)) tdelay=0;
if (!sf_getint("choose", &choose)) choose=nsource;
/*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*/
}
if (incom) {
mask=sf_input("mask"); /*mask operator*/
}
/*--- 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;
ndelay=tdelay/dt;
/* 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);
/*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 != shtnum ) sf_error("Error parameter n3 in record!");
}
/*allocate memory*/
ww=sf_complexalloc(nt);
rr=sf_floatalloc2(nzx,nsource);
lt = sf_complexalloc2(nzx,m2);
rt = sf_complexalloc2(m2,nk);
ltb = sf_complexalloc2(nzx,m2);
rtb = sf_complexalloc2(m2,nk);
geop = (geopar) sf_alloc(1, sizeof(*geop));
mpip = (mpipar) sf_alloc(1, sizeof(*mpip));
tmprec = sf_complexalloc2(nt, gpl);
record = sf_complexalloc3(nt, gpl, shtnum);
if (incom) {
kill = sf_intalloc2(gpl, shtnum);
sf_intread(kill[0],gpl*shtnum,mask);
}
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*m2,leftb);
sf_complexread(rtb[0],m2*nk,rightb);
if(!adj) sf_complexread(img[0],nx*nz,Fimg);
if(adj && wantrecord) {
sf_complexread(record[0][0], shtnum*gpl*nt, Frcd);
if(incom) {
for (is=0; is<shtnum; is++)
for (ix=0; ix<gpl; ix++)
if(kill[is][ix]==0)
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,shtnum);
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-1)/wfint+1);
sf_setd(at, wfdt*wfint);
sf_oaxa(Ftmpwf, az, 1);
sf_oaxa(Ftmpwf, ax, 2);
sf_oaxa(Ftmpwf, at, 3);
sf_settype(Ftmpwf,SF_COMPLEX);
}
}
tstart = clock();
for (is=rank; is<shtnum; is+=nodes) {
spx = shtbgn + shtint*is;
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", is);
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 shtnum=%d", sht0, shtbgn, shtend, 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)
#ifdef _OPENMP
#pragma omp parallel for private(ix,it)
#endif
for (ix=0; ix<gpl; ix++)
for (it=0; it<nt; it++)
tmprec[ix][it] = record[is][ix][it];
if(!fm) {
lrosback2(img, wavefld, sill, tmprec, adj, verb, wantwf, ltb, rtb, m2, geop, pad1, illum);
}
if (adj) {
#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] += img[ix][iz];
}
if (!adj || !wantrecord)
#ifdef _OPENMP
#pragma omp parallel for private(ix,it)
#endif
for (ix=0; ix<gpl; ix++)
for (it=0; it<nt; it++)
record[is][ix][it] = tmprec[ix][it];
if (wantwf && is==0)
for (it=0; it<wfnt; it++) {
if (it%wfint == 0) {
sf_complexwrite(wavefld[it][0], nx*nz, Ftmpwf);
}
}
} /*shot iteration*/
MPI_Barrier(MPI_COMM_WORLD);
/*write record/image*/
if (adj) {
if (rank==0) {
sendbuf = (sf_complex *) MPI_IN_PLACE;
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) {
sendbuf = (sf_complex *) MPI_IN_PLACE;
recvbuf = record[0][0];
} else {
sendbuf = record[0][0];
recvbuf = NULL;
}
MPI_Reduce(sendbuf, recvbuf, shtnum*gpl*nt, MPI_COMPLEX, MPI_SUM, 0, MPI_COMM_WORLD);
if (rank==0) {
if(incom) {
for (is=0; is<shtnum; is++)
for (ix=0; ix<gpl; ix++)
if(kill[is][ix]==0)
for (it=0; it<nt; it++)
record[is][ix][it]=sf_cmplx(0.,0.);
}
sf_complexwrite(record[0][0], shtnum*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);
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);
}
if (incom) {
free(* kill);
free(kill);
}
tend = clock();
duration=(double)(tend-tstart)/CLOCKS_PER_SEC;
sf_warning(">> The CPU time of single shot migration is: %f seconds << ", duration);
MPI_Finalize();
exit(0);
}
int main(int argc, char* argv[])
{
bool adj, verb;
int nd, nm, nx, im, min, max, id, i, ix, sx;
int **indx, *size;
float *model, *data;
sf_file inp, index, out;
sf_init(argc,argv);
if (!sf_getbool("adj",&adj)) adj=true;
/* adjoint flag */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
inp = sf_input("in");
if (SF_FLOAT != sf_gettype(inp))
sf_error("Need float input");
out = sf_output("out");
index = sf_input("index");
if (SF_INT != sf_gettype(index))
sf_error("Need int index");
if (!sf_histint(index,"n1",&nd))
sf_error("No n1= in index");
nm = sf_leftsize(index,1);
if (adj) {
if (nd != sf_filesize(inp))
sf_error("Wrong data size");
} else {
sf_putint(out,"n1",nd);
}
data = sf_floatalloc(nd);
indx = sf_intalloc2(nd,nm);
size = sf_intalloc(nm);
sf_intread(indx[0],nd*nm,index);
nx = 0;
for (im=0; im < nm; im++) {
min = max = indx[im][0];
for (id=1; id < nd; id++) {
i = indx[im][id];
if (i < min) min=i;
if (i > max) max=i;
}
if (min) {
for (id=0; id < nd; id++) {
indx[im][id] -= min;
}
}
size[im]=max-min+1;
nx += size[im];
if (verb) sf_warning("size%d=%d",im+1,size[im]);
}
if (adj) {
sf_putint(out,"n1",nx);
} else {
if (nx != sf_filesize(inp))
sf_error("Wrong model size");
}
model = sf_floatalloc(nx);
if (adj) {
sf_floatread(data,nd,inp);
for (ix=0; ix < nx; ix++) {
model[ix] = 0.0f;
}
} else {
sf_floatread(model,nx,inp);
for (id=0; id < nd; id++) {
data[id] = 0.0f;
}
}
sx=0;
for (im=0; im < nm; im++) {
for (id=0; id < nd; id++) {
ix = indx[im][id]+sx;
if (adj) {
model[ix] += data[id];
} else {
data[id] += model[ix];
}
}
sx += size[im];
}
if (adj) {
sf_floatwrite(model,nx,out);
} else {
sf_floatwrite(data,nd,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
int i, i2, n1, nbuf, **buf, *buf1, nk;
float o1, d1;
off_t n2, nleft;
const char *key;
char *arg;
sf_file in, keys[SF_MAXKEYS], out, tfile;
sf_init (argc,argv);
in = sf_input ("in");
out = sf_output ("out");
if (!sf_histint(in,"n1",&n1) &&
!sf_getint("n1",&n1)) sf_error("Need n1=");
/* number of samples in a trace */
if (!sf_histfloat(in,"d1",&d1) &&
!sf_getfloat("d1",&d1)) sf_error("Need d1=");
/* trace sampling */
if (!sf_histfloat(in,"o1",&o1) &&
!sf_getfloat("o1",&o1)) o1=0;
/* trace origin */
n2 = sf_leftsize(in,1);
nbuf = BUFSIZ/sizeof(int);
if (NULL != sf_getstring("tfile")) {
tfile = sf_input("tfile"); /* trace header file */
if (SF_INT != sf_gettype(tfile))
sf_error("Need integer data in tfile");
if (!sf_histint(tfile,"n1",&nk) || (SF_NKEYS > nk))
sf_error ("Need at least n1=%d keys in tfile",SF_NKEYS);
if (nk*n2 != sf_filesize(tfile))
sf_error ("Wrong number of traces in tfile");
} else {
tfile = NULL;
nk = SF_NKEYS;
}
sf_putint(out,"n1",nk);
sf_settype(out,SF_INT);
if (NULL != tfile) sf_fileflush(out,tfile);
buf = sf_intalloc2(nk,nbuf);
buf1 = sf_intalloc(nbuf);
segy_init(nk,tfile);
for (i=0; i < nk; i++) {
key = segykeyword(i);
if (NULL != (arg = sf_getstring(key))) {
keys[i] = sf_input(key);
if (SF_INT != sf_gettype(keys[i]))
sf_error("Need integer data in file \"%s\"",arg);
if (n2 != sf_filesize(keys[i]))
sf_error("Need filesize=%lld in file \"%s\"",n2,arg);
free(arg);
} else {
keys[i] = NULL;
for (i2=0; i2 < nbuf; i2++) {
buf[i2][i] = 0;
}
}
}
for (nleft=n2; nleft > 0; nleft -= nbuf) {
if (nbuf > nleft) nbuf = nleft;
/* read from initial trace header file */
if (NULL != tfile) sf_intread(buf[0],nk*nbuf,tfile);
for (i=0; i < nk; i++) {
key = segykeyword(i);
if (NULL != keys[i]) {
sf_intread(buf1,nbuf,keys[i]);
for (i2=0; i2 < nbuf; i2++) {
buf[i2][i] = buf1[i2];
}
} else { /* change ns, dt, and delrt */
if (0==strcmp(key,"ns")) {
for (i2=0; i2 < nbuf; i2++) {
buf[i2][i] = n1;
}
} else if (0==strcmp(key,"dt")) {
for (i2=0; i2 < nbuf; i2++) {
buf[i2][i] = (int) (d1*1000000. + 0.5);
}
} else if (0==strcmp(key,"delrt") && o1 != 0) {
keys[i] = NULL;
for (i2=0; i2 < nbuf; i2++) {
buf[i2][i] = (o1>0)? (int) (o1*1000. + 0.5): (int) (o1*1000. - 0.5);
}
}
}
}
sf_intwrite(buf[0],nk*nbuf,out);
}
free(buf1);
free(*buf); free(buf);
exit(0);
}
int main(int argc, char* argv[])
{
int i, j, is, ip, dim, n[SF_MAX_DIM], ii[SF_MAX_DIM];
int nsp, **k=NULL, **l=NULL, n1, n2, i1, i2, kk, ll;
char key[7];
const char *label, *unit;
float f, *trace, *mag=NULL, **p=NULL, pp;
sf_file in, spike;
sf_init (argc,argv);
if (!sf_stdin()) { /* no input file in stdin */
in = NULL;
} else {
in = sf_input("in");
}
spike = sf_output("out");
if (NULL == in) {
sf_setformat(spike,"native_float");
} else if (SF_FLOAT != sf_gettype(in)) {
sf_error("Need float input");
}
/* dimensions */
for (i=0; i < SF_MAX_DIM; i++) {
snprintf(key,3,"n%d",i+1);
if (!sf_getint(key,n+i) &&
(NULL == in || !sf_histint(in,key,n+i))) break;
/*( n# size of #-th axis )*/
sf_putint(spike,key,n[i]);
}
if (0==i) sf_error("Need n1=");
dim=i;
/* basic parameters */
for (i=0; i < dim; i++) {
snprintf(key,3,"o%d",i+1);
if (!sf_getfloat(key,&f) &&
(NULL == in || !sf_histfloat(in,key,&f))) f=0.;
/*( o#=[0,0,...] origin on #-th axis )*/
sf_putfloat(spike,key,f);
snprintf(key,3,"d%d",i+1);
if (!sf_getfloat(key,&f) &&
(NULL == in || !sf_histfloat(in,key,&f))) f = (i==0)? 0.004: 0.1;
/*( d#=[0.004,0.1,0.1,...] sampling on #-th axis )*/
sf_putfloat(spike,key,f);
snprintf(key,7,"label%d",i+1);
if (NULL == (label = sf_getstring(key)) &&
(NULL == in || NULL == (label = sf_histstring(in,key))))
label = (i==0)? "Time":"Distance";
/*( label#=[Time,Distance,Distance,...] label on #-th axis )*/
if (*label != '\0' && (*label != ' ' || *(label+1) != '\0'))
sf_putstring(spike,key,label);
snprintf(key,6,"unit%d",i+1);
if (NULL == (unit = sf_getstring(key)) &&
(NULL == in || NULL == (unit = sf_histstring(in,key))))
unit = (i==0)? "s":"km";
/*( unit#=[s,km,km,...] unit on #-th axis )*/
if (*unit != '\0' && (*unit != ' ' || *(unit+1) != '\0'))
sf_putstring(spike,key,unit);
}
if (NULL != (label = sf_getstring("title")))
sf_putstring(spike,"title",label);
/* title for plots */
if (!sf_getint("nsp",&nsp)) nsp=1;
/* Number of spikes */
if (nsp >= 1) {
mag = sf_floatalloc (nsp);
k = sf_intalloc2 (nsp,dim);
l = sf_intalloc2 (nsp,dim);
p = sf_floatalloc2 (nsp,dim);
for (i=0; i < dim; i++) {
snprintf(key,3,"k%d",i+1);
if ( !sf_getints(key,k[i],nsp)) {
/*( k#=[0,...] spike starting position )*/
for (is=0; is < nsp; is++) {
k[i][is]=-1;
}
} else {
for (is=0; is < nsp; is++) {
if (k[i][is] > n[i])
sf_error("Invalid k%d[%d]=%d > n%d=%d",
i+1,is+1,k[i][is],i+1,n[i]);
k[i][is]--; /* C notation */
}
}
snprintf(key,3,"l%d",i+1);
if (!sf_getints(key,l[i],nsp)) {
/*( l#=[k1,k2,...] spike ending position )*/
for (is=0; is < nsp; is++) {
l[i][is]=k[i][is];
}
} else {
for (is=0; is < nsp; is++) {
if (l[i][is] > n[i])
sf_error("Invalid l%d[%d]=%d > n%d=%d",
i+1,is+1,l[i][is],i+1,n[i]);
l[i][is]--; /* C notation */
}
}
snprintf(key,3,"p%d",i+1);
if (!sf_getfloats(key,p[i],nsp)) {
/*( p#=[0,...] spike inclination (in samples) )*/
for (is=0; is < nsp; is++) {
p[i][is]=0.;
}
}
}
if (!sf_getfloats("mag",mag,nsp)) {
/* spike magnitudes */
for (is=0; is < nsp; is++) {
mag[is]=1.;
}
}
}
n1 = n[0];
n2 = sf_leftsize(spike,1);
trace = sf_floatalloc (n[0]);
for (i2=0; i2 < n2; i2++) { /* loop over traces */
sf_line2cart(dim-1, n+1, i2, ii+1);
/* zero trace */
for (i1=0; i1 < n1; i1++) trace[i1]=0.;
/* put spikes in it */
for (is=0; is < nsp; is++) { /* loop over spikes */
pp = 0.;
for (i=1; i < dim; i++) {
kk = k[i][is];
ll = l[i][is];
if ((kk < -1 && ll < -1) ||
(kk >= 0 && ll >= 0 &&
(kk > ii[i] || ll < ii[i]))) break;
pp += p[i][is]*(ii[i]-k[i][is]-1);
}
if (i < dim) continue; /* skip this spike */
/* linear interpolation */
ip = floorf(pp);
pp = 1.-(pp-ip);
kk = k[0][is];
ll = l[0][is];
if (kk >= 0) { /* one segment per trace */
kk = SF_MAX(kk+ip,0);
ll = SF_MIN(ll+ip,n1-1);
} else {
kk = SF_MAX(ip,0);
ll = SF_MIN(n1-1+ip,n1-1);
}
for (j=kk; j <= ll; j++) {
trace[j] += pp*mag[is];
if (j+1 < n1) trace[j+1] += (1.-pp)*mag[is];
}
}
sf_floatwrite(trace,n1,spike);
}
exit (0);
}
int main (int argc,char* argv[])
{
int i, j, ip, n1, n2, np, ndim, order, n123, *pp, n[2], box[2], **shift, b;
float o1, o2, d1, d2, slow, *dd, **pts, *vv, *h, *bin, *vor, d[2], **rect;
bool isvel, dist, voro;
sf_upgrad upg;
sf_file coord, ord, grid, vel;
sf_init (argc, argv);
ord = sf_input("in");
coord = sf_input("coord");
grid = sf_output("out");
if (NULL != sf_getstring("velocity")) {
vel = sf_input("velocity");
if(!sf_histint(vel,"n1",&n1)) sf_error("No n1= in vel");
if(!sf_histint(vel,"n2",&n2)) sf_error("No n2= in vel");
/* dimensions */
if(!sf_histfloat(vel,"d1",&d1)) sf_error("No d1= in vel");
if(!sf_histfloat(vel,"d2",&d2)) sf_error("No d2= in vel");
/* sampling */
if(!sf_histfloat(vel,"o1",&o1)) o1=0.;
if(!sf_histfloat(vel,"o2",&o2)) o2=0.;
/* origin */
} else {
vel = NULL;
if(!sf_getint("n1",&n1)) sf_error("Need n1=");
if(!sf_getint("n2",&n2)) sf_error("Need n2=");
/* dimensions */
if(!sf_getfloat("d1",&d1)) sf_error("Need d1=");
if(!sf_getfloat("d2",&d2)) sf_error("Need d2=");
/* sampling */
if(!sf_getfloat("o1",&o1)) o1=0.;
if(!sf_getfloat("o2",&o2)) o2=0.;
/* origin */
}
sf_putint(grid,"n1",n1);
sf_putint(grid,"n2",n2);
sf_putfloat(grid,"d1",d1);
sf_putfloat(grid,"d2",d2);
sf_putfloat(grid,"o1",o1);
sf_putfloat(grid,"o2",o2);
n[0]=n1; d[0]=d1;
n[1]=n2; d[1]=d2;
if(!sf_getint("order",&order)) order=2;
/* [1,2] Accuracy order for distance calculation */
if(!sf_getbool("vel",&isvel)) isvel=true;
/* if y, the input is velocity; n, slowness squared */
if (SF_FLOAT != sf_gettype(coord)) sf_error("Need float input");
if(!sf_histint(coord,"n2",&np)) sf_error("No n2= in input");
if(!sf_histint(coord,"n1",&ndim) || ndim > 3) sf_error("Need n1 <= 3 in input");
pts = sf_floatalloc2 (3,np);
for (ip=0; ip < np; ip++) {
sf_floatread(pts[ip],ndim,coord);
pts[ip][2] = 0.0f;
}
n123 = n1*n2;
dd = sf_floatalloc (n123);
vv = sf_floatalloc (n123);
pp = sf_intalloc (n123);
if (NULL != vel) {
sf_floatread(vv,n123,vel);
sf_fileclose(vel);
/* transform velocity to slowness squared */
if (isvel) {
for(i = 0; i < n123; i++) {
slow = vv[i];
vv[i] = 1./(slow*slow);
}
}
} else {
for(i = 0; i < n123; i++) {
vv[i] = 1.;
}
}
/* 1. find distance */
distance_init (1,n2,n1,np);
distance(np,pts,dd,vv,pp,
1,n2,n1,
0.,o2,o1,
1.,d2,d1,
order);
if (!sf_getbool("dist",&dist)) dist=false;
/* if output distance */
if (dist) {
sf_floatwrite(dd,n123,grid);
exit(0);
}
/* 2. binning */
sf_int2_init (pts, o1,o2,d1,d2,n1,n2, sf_bin_int, 1, np);
h = sf_floatalloc(np);
for (ip=0; ip<np; ip++) {
h[ip]=1.0f;
}
sf_int2_lop (true,false,n123,np,vv,h);
if (SF_FLOAT != sf_gettype(ord)) sf_error("Need float input");
sf_floatread(h,np,ord);
bin = sf_floatalloc(n123);
sf_int2_lop (true,false,n123,np,bin,h);
for (i=0; i < n123; i++) {
/* normalize by the fold */
if (vv[i] > FLT_EPSILON) bin[i] /=vv[i];
vv[i]=0.0f;
}
/* 3. voronoi interpolation */
vor = sf_floatalloc(n123);
upg = sf_upgrad_init(2,n,d);
sf_upgrad_set(upg,dd);
sf_upgrad_solve(upg,vv,vor,bin);
if (!sf_getbool("voro",&voro)) voro=false;
/* if output Voronoi diagram */
if (voro) {
sf_floatwrite(vor,n123,grid);
exit(0);
}
/* 4. smoothing */
rect = sf_floatalloc2(n123,2);
shift = sf_intalloc2(n123,2);
for (j=0; j < 2; j++) {
box[j] = 1;
for (i=0; i < n123; i++) {
rect[j][i] = 1.0f+dd[i]/d[j];
b = ceilf(rect[j][i]);
if (b > box[j]) box[j] = b;
shift[j][i] = 0;
}
}
ntrianglen_init(2,box,n,rect,shift,1);
ntrianglen_lop(false,false,n123,n123,vor,bin);
sf_floatwrite(bin,n123,grid);
exit (0);
}
int main(int argc, char* argv[])
{
int n,k,nc,i,j;
int done; /* boolean for more combinations to compute */
int *a; /* list of elements in the current combination (not needed at startup) */
int **mask;
sf_axis areplic;
sf_file in,out;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
sf_settype(out,SF_INT);
if (!sf_getint("k",&k)) sf_error("Need k=");
/* combination of k elements */
/* input file */
if (!sf_histint(in,"n1",&n)) sf_error("No n1=");
nc = binomial(n,k);
sf_warning("Number of combinations is %3d",nc);
/* output file parameters */
areplic = sf_maxa(nc,0,1);
sf_oaxa(out,areplic,2);
sf_putstring (out,"label2", "replication");
/* memory allocations */
a = sf_intalloc(k);
mask = sf_intalloc2(n,nc);
done = 1;
j = 0;
while (1) {
/* Combination of k elements out of n */
comb_next(n,k,a,&done);
if (done) break;
/* done = 1 if more combinations to compute */
/* done = 0 when the list is exhausted. */
for (i = 0; i < k; i++) fprintf(stderr," %3d",a[i]);
fprintf(stderr," \n");
for (i = 0; i < n; i++) mask[j][i] = 1;
for (i = 0; i < k; i++) mask[j][a[i]-1] = 0;
j++;
}
/* output */
sf_warning("Number of combinations is %3d",nc);
sf_intwrite(mask[0],n*nc,out);
exit(0);
}
int main(int argc, char* argv[])
{
bool adj, half, verb, normalize;
int nt, nx, nh, nh2, ix, ih, iy, i, nn, it, **fold, apt;
float *trace, **image, **v, rho, **stack, *pp, *off;
float h, x, t, h0, dh, dx, ti, tx, t0, t1, t2, dt, vi, aal, angle;
sf_file inp, out, vel, gather, offset;
sf_init (argc,argv);
inp = sf_input("in");
vel = sf_input("vel");
out = sf_output("out");
if (!sf_getbool("adj",&adj)) adj=true;
/* adjoint flag (y for migration, n for modeling) */
if (!sf_getbool("normalize",&normalize)) normalize=true;
/* normalize for the fold */
if (!sf_histint(inp,"n1",&nt)) sf_error("No n1=");
if (!sf_histint(inp,"n2",&nx)) sf_error("No n2=");
if (!sf_histfloat(inp,"o1",&t0)) sf_error("No o1=");
if (!sf_histfloat(inp,"d1",&dt)) sf_error("No d1=");
if (!sf_histfloat(inp,"d2",&dx)) sf_error("No d2=");
if (adj) {
if (!sf_histint(inp,"n3",&nh)) sf_error("No n3=");
sf_putint(out,"n3",1);
} else {
if (!sf_getint("nh",&nh)) sf_error("Need nh=");
/* number of offsets (for modeling) */
sf_putint(out,"n3",nh);
}
if (NULL != sf_getstring("gather")) {
gather = sf_output("gather");
} else {
gather = NULL;
}
if (!sf_getfloat("antialias",&aal)) aal = 1.0;
/* antialiasing */
if (!sf_getint("apt",&apt)) apt = nx;
/* integral aperture */
if (!sf_getfloat("angle",&angle)) angle = 90.0;
/* angle aperture */
angle = fabsf(tanf(angle*SF_PI/180.0));
if (!sf_getbool("half",&half)) half = true;
/* if y, the third axis is half-offset instead of full offset */
if (!sf_getbool("verb",&verb)) verb = true;
/* verbosity flag */
if (!sf_getfloat("rho",&rho)) rho = 1.-1./nt;
/* Leaky integration constant */
if (NULL != sf_getstring("offset")) {
offset = sf_input("offset");
nh2 = sf_filesize(offset);
if (nh2 != nh*nx) sf_error("Wrong dimensions in offset");
off = sf_floatalloc(nh2);
sf_floatread (off,nh2,offset);
sf_fileclose(offset);
} else {
if (adj) {
if (!sf_histfloat(inp,"o3",&h0)) sf_error("No o3=");
if (!sf_histfloat(inp,"d3",&dh)) sf_error("No d3=");
sf_putfloat(out,"d3",1.);
sf_putfloat(out,"o3",0.);
} else {
if (!sf_getfloat("dh",&dh)) sf_error("Need dh=");
/* offset sampling (for modeling) */
if (!sf_getfloat("h0",&h0)) sf_error("Need h0=");
/* first offset (for modeling) */
sf_putfloat(out,"d3",dh);
sf_putfloat(out,"o3",h0);
}
if (!half) dh *= 0.5;
off = sf_floatalloc(nh*nx);
for (ix = 0; ix < nx; ix++) {
for (ih = 0; ih < nh; ih++) {
off[ih*nx+ix] = h0 + ih*dh;
}
}
offset = NULL;
}
v = sf_floatalloc2(nt,nx);
sf_floatread(v[0],nt*nx,vel);
trace = sf_floatalloc(nt);
image = sf_floatalloc2(nt,nx);
stack = sf_floatalloc2(nt,nx);
if (normalize) {
fold = sf_intalloc2(nt,nx);
} else {
fold = NULL;
}
nn = 2*kiss_fft_next_fast_size((nt+1)/2);
pp = sf_floatalloc(nn);
sf_halfint_init (true, nn, rho);
if (adj) {
for (i=0; i < nt*nx; i++) {
stack[0][i] = 0.;
}
} else {
sf_floatread(stack[0],nt*nx,inp);
}
if (NULL != fold) {
for (i=0; i < nt*nx; i++) {
fold[0][i] = 0;
}
}
for (ih=0; ih < nh; ih++) {
if (verb) sf_warning("offset %d of %d;",ih+1,nh);
if (adj) {
for (i=0; i < nt*nx; i++) {
image[0][i] = 0.;
}
} else {
for (iy=0; iy < nx; iy++) {
for (it=0; it < nt; it++) {
image[iy][it] = stack[iy][it];
}
}
}
if (!adj) {
for (iy=0; iy < nx; iy++) {
for (it=0; it < nt; it++) {
pp[it] = image[iy][it];
}
for (it=nt; it < nn; it++) {
pp[it] = 0.;
}
sf_halfint (false, pp);
for (it=0; it < nt; it++) {
image[iy][it] = pp[it];
}
}
}
for (iy=0; iy < nx; iy++) {
if (adj) {
sf_floatread (trace,nt,inp);
sf_doubint(true, nt,trace);
} else {
for (it=0; it < nt; it++) {
trace[it]=0.0f;
}
}
h = fabsf(off[ih*nx+iy]);
for (ix=0; ix < nx; ix++) {
x = (ix-iy)*dx;
if (SF_ABS(ix-iy) > apt) continue;
for (it=0; it < nt; it++) {
t = t0 + it*dt;
vi = v[ix][it];
if (fabsf(x) > angle*vi*t) continue;
/* hypot(a,b) = sqrt(a*a+b*b) */
t1 = hypotf(0.5*t,(x-h)/vi);
t2 = hypotf(0.5*t,(x+h)/vi);
ti = t1+t2;
/* tx = |dt/dx| */
tx = fabsf(x-h)/(vi*vi*(t1+dt))+
fabsf(x+h)/(vi*vi*(t2+dt));
pick(adj,ti,fabsf(tx*dx*aal),trace,image[ix],it,nt,dt,t0);
}
}
if (!adj) {
sf_doubint(true, nt,trace);
sf_floatwrite (trace,nt,out);
}
}
if (adj) {
for (iy=0; iy < nx; iy++) {
for (it=0; it < nt; it++) {
pp[it] = image[iy][it];
}
for (it=nt; it < nn; it++) {
pp[it] = 0.;
}
sf_halfint (true, pp);
for (it=0; it < nt; it++) {
image[iy][it] = pp[it];
}
}
if (NULL != gather) sf_floatwrite(image[0],nt*nx,gather);
for (iy=0; iy < nx; iy++) {
for (it=0; it < nt; it++) {
stack[iy][it] += image[iy][it];
if (NULL != fold && 0.!=image[iy][it]) fold[iy][it]++;
}
}
}
}
if (verb) sf_warning(".");
if (NULL != fold) {
for (i=0; i < nt*nx; i++) {
stack[0][i] /= (fold[0][i]+FLT_EPSILON);
}
}
if (adj) sf_floatwrite(stack[0],nt*nx,out);
exit(0);
}
int main(int argc, char* argv[])
{
int nt, nt2, nx, i1, i2, n12, i, j, nx2;
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, * model, * pwdmodel, * outputext, * pwdmodelext;
sf_file inp, out;
/* PWD parameters */
int nw, nj1;
float *pp, *pwdata, *pwdataext;
sf_file dip,outpwdcheck,outdipcheck;
/* kirchhoff params */
bool half, verb,normalize,debug;
int nh, **fold, apt;
float **v, rho, *off;
float h0, dh, aal, angle;
int ix, ih, nh2;
sf_file vel, gather, offset;
/* regularization weight */
float reg;
/* files needed for the extended operator */
float * modelext, * dataext;
// diffmod - diffraction image from the previous iteration
// dipim - dip distribution in the image
sf_file dipim; //diffmod,
//MADAGASCAR C API
/* initialize */
sf_init(argc,argv);
inp = sf_input("in");
out = sf_output("out");
vel = sf_input("vel");
dip = sf_input("dip"); //initialize file with dip
dipim = sf_input("dipim"); //initialize file with image dip
//diffmod = sf_input("diffmod"); //diffraction model from the previous iteration
/* get dimensions from input */
if (!sf_histint(inp,"n1",&nt)) sf_error("No n1= in inp");
if (!sf_histint(inp,"n2",&nx2)) sf_error("No n2= in inp");
// half of the traces - actual data
// half of the traces - model penalization
nx = (int)(nx2)/2;
sf_warning("nx=%d nx2=%d \n",nx,nx2);
sf_warning("nx=%d nx2=%d \n",nx,nx2);
sf_warning("nx=%d nx2=%d \n",nx,nx2);
sf_warning("nx=%d nx2=%d \n",nx,nx2);
sf_warning("nx=%d nx2=%d \n",nx,nx2);
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");
/* get parameters from command line */
/* adjoint flag */
if (!sf_getbool("adj",&adj)) adj=false;
/* if perform derivative filtering = PWD */
if (!sf_getbool("sm",&sm)) sm=true;
/* if perform modelling via Kirchhoff */
if (!sf_getbool("domod",&domod)) domod=true;
/* get regularization parameter */
if (!sf_getfloat("reg",®)) reg=0.0;
/* debug flag */
if (!sf_getbool("debug",&debug)){
debug=false;
outpwdcheck = NULL;
outdipcheck = NULL;
} else {
outpwdcheck = sf_output("outpwd");
outdipcheck = sf_output("outdip");
}
/* kirchhoff parameters */
////////////////////////////////////////////////////////////////////////////////////////
if (!sf_getbool("normalize",&normalize)) normalize=true;
/* normalize for the fold */
if (normalize) {
fold = sf_intalloc2(nt,nx);
} else {
fold = NULL;
}
if (adj) {
if (!sf_histint(inp,"n3",&nh)) sf_error("No n3=");
sf_putint(out,"n3",1);
} else {
if (!sf_getint("nh",&nh)) sf_error("Need nh=");
/* number of offsets (for modeling) */
sf_putint(out,"n3",nh);
}
if (NULL != sf_getstring("gather")) {
gather = sf_output("gather");
} else {
gather = NULL;
}
if (!sf_getfloat("antialias",&aal)) aal = 1.0;
/* antialiasing */
if (!sf_getint("apt",&apt)) apt = nx;
/* integral aperture */
if (!sf_getfloat("angle",&angle)) angle = 90.0;
/* angle aperture */
angle = fabsf(tanf(angle*SF_PI/180.0));
if (!sf_getbool("half",&half)) half = true;
/* if y, the third axis is half-offset instead of full offset */
if (!sf_getbool("verb",&verb)) verb = true;
/* verbosity flag */
if (!sf_getfloat("rho",&rho)) rho = 1.-1./nt;
/* Leaky integration constant */
if (NULL != sf_getstring("offset")) {
offset = sf_input("offset");
nh2 = sf_filesize(offset);
if (nh2 != nh*nx) sf_error("Wrong dimensions in offset");
off = sf_floatalloc(nh2);
sf_floatread (off,nh2,offset);
sf_fileclose(offset);
} else {
if (adj) {
if (!sf_histfloat(inp,"o3",&h0)) sf_error("No o3=");
if (!sf_histfloat(inp,"d3",&dh)) sf_error("No d3=");
sf_putfloat(out,"d3",1.);
sf_putfloat(out,"o3",0.);
} else {
if (!sf_getfloat("dh",&dh)) sf_error("Need dh=");
/* offset sampling (for modeling) */
if (!sf_getfloat("h0",&h0)) sf_error("Need h0=");
/* first offset (for modeling) */
sf_putfloat(out,"d3",dh);
sf_putfloat(out,"o3",h0);
}
if (!half) dh *= 0.5;
off = sf_floatalloc(nh*nx);
for (ix = 0; ix < nx; ix++) {
for (ih = 0; ih < nh; ih++) {
off[ih*nx+ix] = h0 + ih*dh;
}
}
offset = NULL;
}
////////////////////////////////////////////////////////////////////////////////////////
/* path-integral range */
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 */
n12 = nt2*nx;
/*^^^*/
/* extended operator arrays */
dataext = sf_floatalloc(nt*nx);
modelext = sf_floatalloc(nt*nx);
pwdmodel = sf_floatalloc(nt*nx);
pwdmodelext = sf_floatalloc(nt*nx);
outputext = sf_floatalloc(nt*nx);
/* chain arrays */
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);
pwdata = NULL;
// allocate dip
if (sm){
pp = sf_floatalloc(nt*nx); //allocate space for dip
sf_floatread(pp,nt*nx,dip); //read dip
pwdata = sf_floatalloc(nt*nx); //allocate space for pwd data (modelled with kichhoff operator usually)
pwdataext = sf_floatalloc(nt*nx); //allocate space for pwd data
if (!sf_getint("order",&nw)) nw=1;
/* [1,2,3] accuracy order */
if (nw < 1 || nw > 3)
sf_error ("Unsupported nw=%d, choose between 1 and 3",nw);
if (!sf_getint("nj1",&nj1)) nj1=1;
/* antialiasing */
allpass32d_init(allpass_init(nw, nj1, nt,nx,1, pp)); //initialize all-pass-filter structure
}
// allocating and reading velocity
v = sf_floatalloc2(nt,nx);
sf_floatread(v[0],nt*nx,vel);
if(!adj) {
if(domod){// perform modelling
/*^^^*/
// reading data
// first we read actual model
sf_floatread(model,nt*nx,inp);
// here we read diffractivity from the
// previous iteration (should be catenated along
// the second axis)
sf_floatread(modelext,nt*nx,inp);
// modelling via mig2
//^^^^^
mig2_lop(false,half,verb,normalize,nt,nx,nh,fold,apt,data,v,rho,model,off,h0,dh,dx,ot,dt,aal,angle);
mig2_lop(false,half,verb,normalize,nt,nx,nh,fold,apt,dataext,v,rho,modelext,off,h0,dh,dx,ot,dt,aal,angle);
} else {// just read the data
sf_warning("modelling is disabled");
sf_floatread(data,nt*nx,inp);
//sf_floatread(modelext,nt*nx,inp);
} // internal else
if (sm){// perform PWD
//^^^^^
allpass32d_lop(adj,false,nt*nx,nt*nx,data,pwdata);
allpass32d_lop(adj,false,nt*nx,nt*nx,dataext,pwdataext);
/*if (debug){
sf_floatwrite(pwdata,nt*nx,outpwdcheck);
sf_floatwrite(pp,nt*nx,outdipcheck);
}*/
//change the address
for(i=0;i<nt*nx;i++){
data[i]=pwdata[i];
dataext[i]=pwdataext[i];
}
}//PWD flag
} else {// adj flag
/*^^^*/
// read data currently 2D
sf_floatread(data,nt*nx,inp);
// read extended data - zero PWD over reflection
sf_floatread(dataext,nt*nx,inp);
// since adj PWD applied to zero is zero
// lets just put zeroes in the correspoding part of the output
/*for (i1=0;i1<nt*nx;i1++) {
dataext[i1]=0.0;
}*/
}// adj 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
sf_warning("be4 filter");
flatpifilt_init(nt2, nx, dt2, dx, 0.001, v_1, v_2, v_3, v_4, eps);
sf_warning("after filter");
sf_warning("pifilt_init(nt2, nx, dt2, dx, v_a, v_b, v_0, beta, eps);\n");
if(adj) {
sf_warning("be4 the chain: params %d %d %d %d",nt*nx,nt2*nx,nt2*nx,nt*nx);
sf_chain3(t2warp_inv,freqfilt4pi_lop,t2warp,adj,false,nt*nx,nt2*nx,nt2*nx,nt*nx,output,data,outputt2,datat2);
//sf_chain3(t2warp_inv,freqfilt4pi_lop,t2warp,adj,false,nt*nx,nt2*nx,nt2*nx,nt*nx,outputext,data,outputt2,datat2);
sf_warning("running chain");
} else {
sf_chain3(t2warp_inv,freqfilt4pi_lop,t2warp,false,false,nt*nx,nt2*nx,nt2*nx,nt*nx,data,output,datat2,outputt2);
sf_chain3(t2warp_inv,freqfilt4pi_lop,t2warp,false,false,nt*nx,nt2*nx,nt2*nx,nt*nx,dataext,outputext,datat2,outputt2);
}
if(adj) {
if (sm){
sf_warning("performing PWD");
//^^^^^
allpass32d_lop(adj,false,nt*nx,nt*nx,pwdata,output);
//allpass32d_lop(adj,false,nt*nx,nt*nx,pwdataext,outputext);
//change the address
for (i=0;i<nt*nx;i++){
output[i]=pwdata[i];
//outputext[i]=pwdataext[i];
}
}
if (domod) {
sf_warning("performing Kirchhoff migration");
//^^^^^
mig2_lop(true,half,verb,normalize,nt,nx,nh,fold,apt,output,v,rho,model,off,h0,dh,dx,ot,dt,aal,angle);
//mig2_lop(true,half,verb,normalize,nt,nx,nh,fold,apt,outputext,v,rho,modelext,off,h0,dh,dx,ot,dt,aal,angle);
} else {
sf_warning("changing the address");
//change the address
for (i=0;i<nt*nx;i++){
model[i]=output[i];
}
}
} // adj flag
sf_warning("done with output");
if (sm){
// pp = sf_floatalloc(nt*nx); //allocate space for dip
sf_floatread(pp,nt*nx,dipim); //read dipim
// we need to re-initialize allpass filter
// so that it operates in the image domain
allpass32d_init(allpass_init(nw, nj1, nt,nx,1, pp)); //initialize all-pass-filter structure
// all other parameters are supposed to be initialized previously
if(!adj) {
// perform adj pwd in the image domain on the model and diffraction model
allpass32d_lop(adj,false,nt*nx,nt*nx,model,pwdmodel);
for(j=0;j<nx*nt;j++){
output[j] = output[j] + outputext[j];
outputext[j] = reg*pwdmodel[j];
}
} else {
allpass32d_lop(adj,false,nt*nx,nt*nx,pwdmodelext,dataext);
for(j=0;j<nx*nt;j++){
modelext[j] = model[j];
model[j] = model[j] + reg*pwdmodelext[j];
}//for
}
}
if (!adj) {
// write
sf_floatwrite(output,nt*nx,out);
// write extended output
sf_floatwrite(outputext,nt*nx,out);
} else {
// write
sf_floatwrite(model,nt*nx,out);
// equivalent to setting reflection component to zero
sf_floatwrite(modelext,nt*nx,out);
}
exit(0);
}
/*------------------------------------------------------------*/
cam3d cam3_init(cub3d cub,
int pmx,
int pmy,
int phx,
int tmx,
int tmy,
int thx,
float dsmax
)
/*< initialize >*/
{
int imy, imx, ihx;
float kmx, khx;
int jmx, jhx;
int ilx, ily;
float my, mx, hx, k;
/*------------------------------------------------------------*/
cam3d cam;
cam = (cam3d) sf_alloc(1,sizeof(*cam));
X2K(cub->amx,cam->bmx,pmx);
X2K(cub->amy,cam->bmy,pmy);
X2K(cub->ahx,cam->bhx,phx);
/* allocate K-domain storage */
cam->wk = sf_complexalloc4 (cam->bmx.n,cam->bmy.n,cam->bhx.n,cub->ompnth);
cam->pk = sf_complexalloc4 (cam->bmx.n,cam->bmy.n,cam->bhx.n,cub->ompnth);
/* allocate X-domain storage */
cam->wt = sf_floatalloc4 (cub->amx.n,cub->amy.n,cub->ahx.n,cub->ompnth);
cam->ksx = sf_floatalloc2(cam->bmx.n,cam->bhx.n);
cam->krx = sf_floatalloc2(cam->bmx.n,cam->bhx.n);
for (imx=0; imx<cam->bmx.n; imx++) {
jmx = KMAP(imx,cam->bmx.n);
kmx = cam->bmx.o + jmx*cam->bmx.d;
for (ihx=0; ihx<cam->bhx.n; ihx++) {
jhx = KMAP(ihx,cam->bhx.n);
khx = cam->bhx.o + jhx*cam->bhx.d;
k = 0.5*(kmx-khx);
cam->ksx[ihx][imx] = k*k; /* ksx^2 */
k = 0.5*(kmx+khx);
cam->krx[ihx][imx] = k*k; /* krx^2 */
}
}
/* precompute indices */
cam->jx = sf_intalloc(cub->amx.n);
cam->jy = sf_intalloc(cub->amy.n);
cam->is = sf_intalloc2(cub->amx.n,cub->ahx.n); /* source index */
cam->ir = sf_intalloc2(cub->amx.n,cub->ahx.n); /* receiver index */
for (imy=0; imy<cub->amy.n; imy++) {
my = cub->amy.o + imy*cub->amy.d;
ily = INDEX( my,cub->aly);
cam->jy[imy] = BOUND(ily,cub->aly.n); /* x-line index */
}
for (imx=0; imx<cub->amx.n; imx++) {
mx = cub->amx.o + imx*cub->amx.d;
ilx = INDEX( mx,cub->alx);
cam->jx[imx] = BOUND(ilx,cub->alx.n); /* i-line index */
for (ihx=0; ihx<cub->ahx.n; ihx++) {
hx = cub->ahx.o + ihx*cub->ahx.d;
ilx = INDEX(mx-hx,cub->alx);
cam->is[ihx][imx] = BOUND( ilx,cub->alx.n); /* source index */
ilx = INDEX(mx+hx,cub->alx);
cam->ir[ihx][imx] = BOUND( ilx,cub->alx.n); /* receiver index */
}
}
/* initialize FFT */
cam->f3d = ompfft3_init(cub,cam->bmx.n,cam->bmy.n,cam->bhx.n);
cam->dsmax2 = dsmax*dsmax;
cam->dsmax2*= cam->dsmax2;
return cam;
}
int main(int argc, char* argv[])
{
bool verb,isreversed;
sf_file Fs,Fr,Fi,Fc; /* I/O files */
sf_axis az,ax,at,ac,aa; /* cube axes */
int nz,nx,nt, nhx, nhz, nht,nc;
int it, ihx, ihz, iht,ic;
int nhx2,nhz2,nht2;
off_t iseek;
float ***us=NULL,***ur=NULL,****ii=NULL;
pt2d *cc=NULL;
bool *ccin=NULL;
float cxmin,czmin;
float cxmax,czmax;
int icx, icz;
int mcx, mcz, mct;
int pcx, pcz, pct;
int **mcxall, **pcxall;
int **mczall, **pczall;
int *mctall, *pctall;
int lht;
float scale;
/* gaussian taper */
bool gaus;
float gsx,gsz,gst; /* std dev */
float gx, gz, gt;
/*------------------------------------------------------------*/
/* init RSF */
sf_init(argc,argv);
/* OMP parameters */
#ifdef _OPENMP
omp_init();
#endif
if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */
if(! sf_getbool("isreversed",&isreversed)) isreversed=false; /* reversed rec wfld? */
Fs = sf_input ("in" ); /* source wavefield */
Fr = sf_input ("ur" ); /* receiver wavefield */
Fc = sf_input ("cc" ); /* CIP coordinates */
Fi = sf_output("out"); /* image */
/*------------------------------------------------------------*/
/* read axes */
az=sf_iaxa(Fs,1); nz = sf_n(az);
ax=sf_iaxa(Fs,2); nx = sf_n(ax);
at=sf_iaxa(Fs,3); nt = sf_n(at);
/* CIP coordinates */
ac = sf_iaxa(Fc,2); sf_setlabel(ac,"cc"); sf_setunit(ac,"");
nc = sf_n(ac);
if(! sf_getint("nhz",&nhz)) nhz=0; nhz2=2*nhz+1; /* z lags */
if(! sf_getint("nhx",&nhx)) nhx=0; nhx2=2*nhx+1; /* x lags */
if(! sf_getint("nht",&nht)) nht=0; nht2=2*nht+1; /* t lags */
lht=2*nht;
if(verb) {
sf_warning("nhx=%3d nhz=%3d nht=%3d",nhx2,nhz2,nht2);
sf_raxa(az);
sf_raxa(ax);
sf_raxa(at);
sf_raxa(ac);
}
/* set output axes */
aa=sf_maxa(nhz2,-nhz*sf_d(az),sf_d(az));
sf_setlabel(aa,"hz"); sf_setunit(aa,"");
if(verb) sf_raxa(aa);
sf_oaxa(Fi,aa,1);
aa=sf_maxa(nhx2,-nhx*sf_d(ax),sf_d(ax));
sf_setlabel(aa,"hx"); sf_setunit(aa,"");
if(verb) sf_raxa(aa);
sf_oaxa(Fi,aa,2);
aa=sf_maxa(nht2,-nht*sf_d(at),sf_d(at));
sf_setlabel(aa,"ht"); sf_setunit(aa,"");
if(verb) sf_raxa(aa);
sf_oaxa(Fi,aa,3);
sf_oaxa(Fi,ac,4);
if(! sf_getbool("gaus",&gaus)) gaus=false; /* Gaussian taper flag */
if(gaus) {
if(! sf_getfloat("gsx",&gsx)) gsx=nhx*sf_d(ax); gsx=1./(2*gsx*gsx);
if(! sf_getfloat("gsz",&gsz)) gsz=nhz*sf_d(az); gsz=1./(2*gsz*gsz);
if(! sf_getfloat("gst",&gst)) gst=nht*sf_d(at); gst=1./(2*gst*gst);
}
/*------------------------------------------------------------*/
/* allocate work arrays */
us=sf_floatalloc3(nz,nx,nht2);
ur=sf_floatalloc3(nz,nx,nht2);
ii=sf_floatalloc4(nhz2,nhx2,nht2,nc);
/* zero output */
for(ic=0; ic<nc; ic++) {
for (iht=0; iht<nht2; iht++) {
for (ihx=0; ihx<nhx2; ihx++) {
for(ihz=0; ihz<nhz2; ihz++) {
ii[ic][iht][ihx][ihz] = 0;
}
}
}
}
/*------------------------------------------------------------*/
/* CIP coordinates */
cc= (pt2d*) sf_alloc(nc,sizeof(*cc));
pt2dread1(Fc,cc,nc,2);
mcxall=sf_intalloc2(nhx2,nc);
pcxall=sf_intalloc2(nhx2,nc);
mczall=sf_intalloc2(nhz2,nc);
pczall=sf_intalloc2(nhz2,nc);
ccin=sf_boolalloc(nc);
cxmin = sf_o(ax) + nhx *sf_d(ax);
cxmax = sf_o(ax) + (sf_n(ax)-1-nhx)*sf_d(ax);
czmin = sf_o(az) + nhz *sf_d(az);
czmax = sf_o(az) + (sf_n(az)-1-nhz)*sf_d(az);
if(verb) {
sf_warning("cxmin=%f,cxmax=%f",cxmin,cxmax);
sf_warning("czmin=%f,czmax=%f",czmin,czmax);
}
for(ic=0; ic<nc; ic++) {
ccin[ic]=(cc[ic].x>=cxmin && cc[ic].x<=cxmax &&
cc[ic].z>=czmin && cc[ic].z<=czmax)?true:false;
if(ccin[ic]) {
icx = 0.5+(cc[ic].x-sf_o(ax))/sf_d(ax);
for(ihx=-nhx; ihx<nhx+1; ihx++) {
mcxall[ic][nhx+ihx] = icx-ihx;
pcxall[ic][nhx+ihx] = icx+ihx;
}
icz = 0.5+(cc[ic].z-sf_o(az))/sf_d(az);
for(ihz=-nhz; ihz<nhz+1; ihz++) {
mczall[ic][nhz+ihz] = icz-ihz;
pczall[ic][nhz+ihz] = icz+ihz;
}
}
}
mctall=sf_intalloc(nht2);
pctall=sf_intalloc(nht2);
for (iht=0; iht<nht2; iht++) {
mctall[iht]=iht;
pctall[iht]=2*nht-iht;
}
/*------------------------------------------------------------*/
if(isreversed) { /* receiver wavefield is reversed */
/* read wavefield @ [0...2nht-1]*/
for(iht=0;iht<2*nht;iht++) {
sf_floatread(us[iht][0],nz*nx,Fs);
sf_floatread(ur[iht][0],nz*nx,Fr);
}
if(verb) fprintf(stderr,"nt\n");
for(it=nht;it<nt-nht;it++) {
if(verb) fprintf(stderr,"\b\b\b\b\b\b\b\b\b\b%04d",it);
/* read wavefield @ [2nht]*/
sf_floatread(us[ lht ][0],nz*nx,Fs);
sf_floatread(ur[ lht ][0],nz*nx,Fr);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) \
private(ic, \
ihx,ihz,iht, \
mcx,mcz,mct, \
pcx,pcz,pct) \
shared (nc,ii,us,ur, \
nhx2, nhz2, nht2, \
mcxall,mczall,mctall, \
pcxall,pczall,pctall,ccin)
#endif
for(ic=0; ic<nc; ic++) {
if(ccin[ic]) {
for (iht=0; iht<nht2; iht++) { mct=mctall [iht]; pct=pctall [iht];
for (ihx=0; ihx<nhx2; ihx++) { mcx=mcxall[ic][ihx]; pcx=pcxall[ic][ihx];
for(ihz=0; ihz<nhz2; ihz++) { mcz=mczall[ic][ihz]; pcz=pczall[ic][ihz];
ii[ic][iht][ihx][ihz] += us[mct][mcx][mcz]*ur[pct][pcx][pcz];
} /* ihz */
} /* ihx */
} /* iht */
}
} /* ic */
/* update wavefield index (cycle) */
for(iht=0;iht<nht2;iht++) {
mctall[iht] = (mctall[iht]+1) % nht2;
pctall[iht] = (pctall[iht]+1) % nht2;
}
lht = (lht+1) % nht2;
} /* it */
if(verb) fprintf(stderr,"\n");
} else { /* receiver wavefield is NOT reversed */
/* read wavefield @ [0...2nht-1]*/
for(iht=0;iht<2*nht;iht++) {
sf_floatread(us[iht][0],nz*nx,Fs);
iseek = (off_t)(nt-1-iht)*nz*nx*sizeof(float);
sf_seek(Fr,iseek,SEEK_SET);
sf_floatread(ur[iht][0],nz*nx,Fr);
}
if(verb) fprintf(stderr,"nt\n");
for(it=nht;it<nt-nht;it++) {
if(verb) fprintf(stderr,"\b\b\b\b\b\b\b\b\b\b%04d",nt-nht-1-it);
/* read wavefield @ [2nht]*/
sf_floatread(us[ lht ][0],nz*nx,Fs);
iseek=(off_t)(nt-nht-1-it)*nz*nx*sizeof(float);
sf_seek(Fr,iseek,SEEK_SET);
sf_floatread(ur[ lht ][0],nz*nx,Fr);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) \
private(ic, \
ihx,ihz,iht, \
mcx,mcz,mct, \
pcx,pcz,pct) \
shared (nc,ii,us,ur, \
nhx2, nhz2, nht2, \
mcxall,mczall,mctall, \
pcxall,pczall,pctall,ccin)
#endif
for(ic=0; ic<nc; ic++) {
if(ccin[ic]) {
for (iht=0; iht<nht2; iht++) { mct=mctall [iht]; pct=pctall [iht];
for (ihx=0; ihx<nhx2; ihx++) { mcx=mcxall[ic][ihx]; pcx=pcxall[ic][ihx];
for(ihz=0; ihz<nhz2; ihz++) { mcz=mczall[ic][ihz]; pcz=pczall[ic][ihz];
ii[ic][iht][ihx][ihz] += us[mct][mcx][mcz]*ur[pct][pcx][pcz];
} /* ihz */
} /* ihx */
} /* iht */
}
} /* ic */
/* update wavefield index (cycle) */
for(iht=0;iht<nht2;iht++) {
mctall[iht] = (mctall[iht]+1) % nht2;
pctall[iht] = (pctall[iht]+1) % nht2;
}
lht = (lht+1) % nht2;
} /* it */
if(verb) fprintf(stderr,"\n");
} /* end "is reversed" */
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
/* scale image */
scale = 1./nt;
for(ic=0; ic<nc; ic++) {
for (iht=0; iht<nht2; iht++) {
for (ihx=0; ihx<nhx2; ihx++) {
for(ihz=0; ihz<nhz2; ihz++) {
ii[ic][iht][ihx][ihz] *= scale;
}
}
}
}
/*------------------------------------------------------------*/
/* apply Gaussian taper */
if(gaus) {
for(ic=0; ic<nc; ic++) {
for (iht=0;iht<nht2;iht++) { gt=(iht-nht)*sf_d(at); gt*=gt;
for (ihx=0;ihx<nhx2;ihx++) { gx=(ihx-nhx)*sf_d(ax); gx*=gx;
for(ihz=0;ihz<nhz2;ihz++) { gz=(ihz-nhz)*sf_d(az); gz*=gz;
ii[ic][iht][ihx][ihz] *= exp(-gt*gst - gx*gsx - gz*gsz);
}
}
}
}
}
/*------------------------------------------------------------*/
/* write image */
sf_floatwrite(ii[0][0][0],nc*(nhx2)*(nhz2)*(nht2),Fi);
/*------------------------------------------------------------*/
/* deallocate arrays */
free(***ii); free(**ii); free(*ii); free(ii);
free(*us); free(us);
free(*ur); free(ur);
free(cc);
free(ccin);
free(*mcxall); free(mcxall);
free(*pcxall); free(pcxall);
free(*mczall); free(mczall);
free(*pczall); free(pczall);
/*------------------------------------------------------------*/
exit (0);
}
int main(int argc, char* argv[])
{
int nt, nt2, nx, i1, i2, n12, i, j;
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, * model;
sf_file inp, out;
/* PWD parameters */
int nw, nj1;
float *pp, *pwdata;
sf_file dip,outpwdcheck,outdipcheck;
/* kirchhoff params */
bool half, verb,normalize,debug;
int nh, **fold, apt;
float **v, rho, *off;
float h0, dh, aal, angle;
int ix, ih, nh2;
sf_file vel, gather, offset;
//MADAGASCAR C API
/* initialize */
sf_init(argc,argv);
inp = sf_input("in");
out = sf_output("out");
vel = sf_input("vel");
dip = sf_input("dip"); //initialize file with dip
/* 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");
/* get parameters from command line */
/* adjoint flag */
if (!sf_getbool("adj",&adj)) adj=false;
/* if perform derivative filtering = PWD */
if (!sf_getbool("sm",&sm)) sm=true;
/* if perform modelling via Kirchhoff */
if (!sf_getbool("domod",&domod)) domod=true;
/* debug flag */
if (!sf_getbool("debug",&debug)){
debug=false;
outpwdcheck = NULL;
outdipcheck = NULL;
} else {
outpwdcheck = sf_output("outpwd");
outdipcheck = sf_output("outdip");
}
/* kirchhoff parameters */
////////////////////////////////////////////////////////////////////////////////////////
if (!sf_getbool("normalize",&normalize)) normalize=true;
/* normalize for the fold */
if (normalize) {
fold = sf_intalloc2(nt,nx);
} else {
fold = NULL;
}
if (adj) {
if (!sf_histint(inp,"n3",&nh)) sf_error("No n3=");
sf_putint(out,"n3",1);
} else {
if (!sf_getint("nh",&nh)) sf_error("Need nh=");
/* number of offsets (for modeling) */
sf_putint(out,"n3",nh);
}
if (NULL != sf_getstring("gather")) {
gather = sf_output("gather");
} else {
gather = NULL;
}
if (!sf_getfloat("antialias",&aal)) aal = 1.0;
/* antialiasing */
if (!sf_getint("apt",&apt)) apt = nx;
/* integral aperture */
if (!sf_getfloat("angle",&angle)) angle = 90.0;
/* angle aperture */
angle = fabsf(tanf(angle*SF_PI/180.0));
if (!sf_getbool("half",&half)) half = true;
/* if y, the third axis is half-offset instead of full offset */
if (!sf_getbool("verb",&verb)) verb = true;
/* verbosity flag */
if (!sf_getfloat("rho",&rho)) rho = 1.-1./nt;
/* Leaky integration constant */
if (NULL != sf_getstring("offset")) {
offset = sf_input("offset");
nh2 = sf_filesize(offset);
if (nh2 != nh*nx) sf_error("Wrong dimensions in offset");
off = sf_floatalloc(nh2);
sf_floatread (off,nh2,offset);
sf_fileclose(offset);
} else {
if (adj) {
if (!sf_histfloat(inp,"o3",&h0)) sf_error("No o3=");
if (!sf_histfloat(inp,"d3",&dh)) sf_error("No d3=");
sf_putfloat(out,"d3",1.);
sf_putfloat(out,"o3",0.);
} else {
if (!sf_getfloat("dh",&dh)) sf_error("Need dh=");
/* offset sampling (for modeling) */
if (!sf_getfloat("h0",&h0)) sf_error("Need h0=");
/* first offset (for modeling) */
sf_putfloat(out,"d3",dh);
sf_putfloat(out,"o3",h0);
}
if (!half) dh *= 0.5;
off = sf_floatalloc(nh*nx);
for (ix = 0; ix < nx; ix++) {
for (ih = 0; ih < nh; ih++) {
off[ih*nx+ix] = h0 + ih*dh;
}
}
offset = NULL;
}
////////////////////////////////////////////////////////////////////////////////////////
/* path-integral range */
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 */
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);
pwdata = NULL;
// allocate dip
if (sm){
pp = sf_floatalloc(nt*nx); //allocate space for dip
sf_floatread(pp,nt*nx,dip); //read dip
pwdata = sf_floatalloc(nt*nx); //allocate space for pwd data
if (!sf_getint("order",&nw)) nw=1;
/* [1,2,3] accuracy order */
if (nw < 1 || nw > 3)
sf_error ("Unsupported nw=%d, choose between 1 and 3",nw);
if (!sf_getint("nj1",&nj1)) nj1=1;
/* antialiasing */
allpass32d_init(allpass_init(nw, nj1, nt,nx,1, pp)); //initialize all-pass-filter structure
}
// allocating and reading velocity
v = sf_floatalloc2(nt,nx);
sf_floatread(v[0],nt*nx,vel);
if(!adj) {
if(domod){// perform modelling
// reading data
sf_floatread(model,nt*nx,inp);
// modelling via mig2
mig2_lop(false,half,verb,normalize,nt,nx,nh,fold,apt,data,v,rho,model,off,h0,dh,dx,ot,dt,aal,angle);
} else {// just read the data
sf_warning("modelling is disabled");
sf_floatread(data,nt*nx,inp);
} // internal else
if (sm){// perform PWD
allpass32d_lop(adj,false,nt*nx,nt*nx,data,pwdata);
if (debug){
sf_floatwrite(pwdata,nt*nx,outpwdcheck);
sf_floatwrite(pp,nt*nx,outdipcheck);
}
//change the address
for(i=0;i<nt*nx;i++){
data[i]=pwdata[i];
}
}//PWD flag
} else {// adj flag
// read data currently 2D
sf_floatread(data,nt*nx,inp);
}// adj 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
sf_warning("be4 filter");
flatpifilt_init(nt2, nx, dt2, dx, 0.001, v_1, v_2, v_3, v_4, eps);
sf_warning("after filter");
sf_warning("pifilt_init(nt2, nx, dt2, dx, v_a, v_b, v_0, beta, eps);\n");
if(adj) {
sf_warning("be4 the chain: params %d %d %d %d",nt*nx,nt2*nx,nt2*nx,nt*nx);
sf_chain3(t2warp_inv,freqfilt4pi_lop,t2warp,adj,false,nt*nx,nt2*nx,nt2*nx,nt*nx,output,data,outputt2,datat2);
sf_warning("running chain");
} else {
sf_chain3(t2warp_inv,freqfilt4pi_lop,t2warp,false,false,nt*nx,nt2*nx,nt2*nx,nt*nx,data,output,datat2,outputt2);
}
if(adj) {
if (sm){
sf_warning("performing PWD");
allpass32d_lop(adj,false,nt*nx,nt*nx,pwdata,output);
//change the address
for (i=0;i<nt*nx;i++){
output[i]=pwdata[i];
}
}
if (domod) {
sf_warning("performing Kirchhoff migration");
mig2_lop(true,half,verb,normalize,nt,nx,nh,fold,apt,output,v,rho,model,off,h0,dh,dx,ot,dt,aal,angle);
} else {
sf_warning("changing the address");
//change the address
for (i=0;i<nt*nx;i++){
model[i]=output[i];
}
}
} // adj flag
sf_warning("done with output");
if (!adj) {
// write
sf_floatwrite(output,nt*nx,out);
} else {
// write
sf_floatwrite(model,nt*nx,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
bool adj, velocity, l1norm, plane[3], verb;
int dim, i, count, n[SF_MAX_DIM], it, nt, **m, nrhs, is, nshot=1, *flag, order, iter, niter, stiter, *k, nfreq, nmem;
float o[SF_MAX_DIM], d[SF_MAX_DIM], **t, *t0, *s, *temps, **source, *rhs, *ds;
float rhsnorm, rhsnorm0, rhsnorm1, rate, eps, gama;
char key[4], *what;
sf_file sinp, sout, shot, time, reco, rece, topo, grad, norm;
sf_weight weight=NULL;
sf_init(argc,argv);
sinp = sf_input("in");
sout = sf_output("out");
if (NULL == (what = sf_getstring("what"))) what="tomo";
/* what to compute (default tomography) */
switch (what[0]) {
case 'l': /* linear operator */
if (NULL == sf_getstring("time"))
sf_error("Need time=");
time = sf_input("time");
/* read operator dimension from time table */
dim = sf_filedims(time,n);
nt = 1;
for (i=0; i < 3; i++) {
sprintf(key,"d%d",i+1);
if (!sf_histfloat(time,key,d+i)) sf_error("No %s= in input",key);
sprintf(key,"o%d",i+1);
if (!sf_histfloat(time,key,o+i)) o[i]=0.;
nt *= n[i]; plane[i] = false;
}
if (dim < 3) {
n[2] = 1; o[2] = o[1]; d[2] = d[1]; plane[2] = false;
}
dim = 2;
/* read in shot file */
if (NULL == sf_getstring("shot"))
sf_error("Need source shot=");
shot = sf_input("shot");
if (!sf_histint(shot,"n2",&nshot)) nshot=1;
sf_fileclose(shot);
/* read in receiver file */
m = sf_intalloc2(nt,nshot);
if (NULL == sf_getstring("receiver")) {
for (is=0; is < nshot; is++) {
for (it=0; it < nt; it++) {
m[is][it] = 1;
}
}
} else {
rece = sf_input("receiver");
sf_intread(m[0],nt*nshot,rece);
sf_fileclose(rece);
}
/* number of right-hand side */
nrhs = 0;
for (is=0; is < nshot; is++) {
for (it=0; it < nt; it++) {
if (m[is][it] == 1) nrhs++;
}
}
rhs = sf_floatalloc(nrhs);
t = sf_floatalloc2(nt,nshot);
sf_floatread(t[0],nt*nshot,time);
if (!sf_getbool("adj",&adj)) adj=false;
/* adjoint flag (for what=linear) */
/* initialize fatomo */
fatomo_init(dim,n,d,nshot);
/* set operators */
fatomo_set(t,m);
t0 = sf_floatalloc(nt);
if (adj) {
sf_floatread(rhs,nrhs,sinp);
fatomo_lop(true,false,nt,nrhs,t0,rhs);
sf_putint(sout,"n1",nt);
sf_putint(sout,"n2",1);
sf_putint(sout,"n3",1);
sf_floatwrite(t0,nt,sout);
} else {
sf_floatread(t0,nt,sinp);
fatomo_lop(false,false,nt,nrhs,t0,rhs);
sf_putint(sout,"n1",nrhs);
sf_putint(sout,"n2",1);
sf_putint(sout,"n3",1);
sf_floatwrite(rhs,nrhs,sout);
}
break;
case 't': /* tomography */
/* read input dimension */
dim = sf_filedims(sinp,n);
nt = 1;
for (i=0; i < dim; i++) {
sprintf(key,"d%d",i+1);
if (!sf_histfloat(sinp,key,d+i)) sf_error("No %s= in input",key);
sprintf(key,"o%d",i+1);
if (!sf_histfloat(sinp,key,o+i)) o[i]=0.;
nt *= n[i]; plane[i] = false;
}
if (dim < 3) {
n[2] = 1; o[2] = o[1]; d[2] = d[1]; plane[2] = false;
}
/* read initial guess */
s = sf_floatalloc(nt);
sf_floatread(s,nt,sinp);
if (!sf_getbool("velocity",&velocity)) velocity=true;
/* if y, the input is velocity; n, slowness squared */
if (velocity) {
for (it=0; it < nt; it++) {
s[it] = 1./s[it]*1./s[it];
}
}
/* allocate memory for temporary data */
ds = sf_floatalloc(nt);
flag = sf_intalloc(nt);
temps = sf_floatalloc(nt);
for (it=0; it < nt; it++) {
temps[it] = s[it];
}
if (!sf_getbool("l1norm",&l1norm)) l1norm=false;
/* norm for minimization (default L2 norm) */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
/* read in shot file */
if (NULL == sf_getstring("shot"))
sf_error("Need source shot=");
shot = sf_input("shot");
if (!sf_histint(shot,"n2",&nshot)) nshot=1;
source = sf_floatalloc2(3,nshot);
sf_floatread(source[0],3*nshot,shot);
sf_fileclose(shot);
/* allocate memory for time table */
t = sf_floatalloc2(nt,nshot);
/* read in receiver file */
m = sf_intalloc2(nt,nshot);
if (NULL == sf_getstring("receiver")) {
for (is=0; is < nshot; is++) {
for (it=0; it < nt; it++) {
m[is][it] = 1;
}
}
} else {
rece = sf_input("receiver");
sf_intread(m[0],nt*nshot,rece);
sf_fileclose(rece);
}
/* number of right-hand side */
nrhs = 0;
for (is=0; is < nshot; is++) {
for (it=0; it < nt; it++) {
if (m[is][it] == 1) nrhs++;
}
}
rhs = sf_floatalloc(nrhs);
/* read in record file */
if (NULL == sf_getstring("record"))
sf_error("Need data record=");
reco = sf_input("record");
t0 = sf_floatalloc(nrhs);
sf_floatread(t0,nrhs,reco);
sf_fileclose(reco);
/* read in topography file */
if (NULL != sf_getstring("topo")) {
topo = sf_input("topo");
k = sf_intalloc(nt);
sf_intread(k,nt,topo);
sf_fileclose(topo);
} else {
k = NULL;
}
if (!sf_getint("order",&order)) order=2;
/* fast marching accuracy order */
if (!sf_getint("niter",&niter)) niter=10;
/* number of slowness inversion iterations */
if (!sf_getint("stiter",&stiter)) stiter=200;
/* number of step iterations */
if (!sf_getfloat("eps",&eps)) eps=0.;
/* regularization parameter */
/* output gradient at each iteration */
if (NULL != sf_getstring("gradient")) {
grad = sf_output("gradient");
sf_putint(grad,"n3",n[2]);
sf_putfloat(grad,"d3",d[2]);
sf_putfloat(grad,"o3",o[2]);
sf_putint(grad,"n4",niter);
} else {
grad = NULL;
}
/* output misfit L2 norm at each iteration */
if (NULL != sf_getstring("misnorm")) {
norm = sf_output("misnorm");
sf_putint(norm,"n1",niter+1);
sf_putfloat(norm,"d1",1.);
sf_putfloat(norm,"o1",0.);
sf_putint(norm,"n2",1);
sf_putint(norm,"n3",1);
} else {
norm = NULL;
}
/* initialize fatomo */
fatomo_init(dim,n,d,nshot);
/* initialize 2D gradient operator */
sf_igrad2_init(n[0],n[1]);
if (l1norm) {
/*
if (!sf_getfloat("perc",&perc)) perc=90.;
l1_init(nt,stiter,perc,false);
*/
if (!sf_getint("nfreq",&nfreq)) nfreq=1;
/* l1-norm weighting nfreq */
if (!sf_getint("nmem",&nmem)) nmem=1;
/* l1-norm weighting nmem */
weight = sf_l1;
sf_irls_init(nt);
}
/* initial misfit */
fastmarch_init(n[2],n[1],n[0]);
i = 0;
for (is=0; is < nshot; is++) {
fastmarch(t[is],s,flag,plane,
n[2],n[1],n[0],o[2],o[1],o[0],d[2],d[1],d[0],
source[is][2],source[is][1],source[is][0],1,1,1,order);
for (it=0; it < nt; it++) {
if (m[is][it] == 1) {
rhs[i] = t0[i]-t[is][it];
i++;
}
}
}
fastmarch_close();
/* calculate L2 data-misfit */
rhsnorm0 = cblas_snrm2(nrhs,rhs,1);
rhsnorm = rhsnorm0;
rhsnorm1 = rhsnorm;
rate = rhsnorm1/rhsnorm0;
if (l1norm)
sf_warning("L1 misfit after iteration 0 of %d: %g",niter,rate);
else
sf_warning("L2 misfit after iteration 0 of %d: %g",niter,rate);
if (norm != NULL) sf_floatwrite(&rate,1,norm);
/* iterations over inversion */
for (iter=0; iter < niter; iter++) {
/* clean-up */
for (it=0; it < nt; it++) {
ds[it] = 0.;
}
/* prepare for CG */
fatomo_set(t,m);
/* solve ds */
if (l1norm) {
/*
sf_solver_reg(fatomo_lop,l1step,sf_igrad2_lop,2*nt, nt,nrhs,ds,rhs,stiter,eps,"verb",verb,"end");
*/
sf_solver_reg(fatomo_lop,sf_cgstep,sf_igrad2_lop,2*nt,nt,nrhs,ds,rhs,stiter,eps,"wght",weight,"nfreq",nfreq,"nmem",nmem,"verb",verb,"end");
/*
l1step_close();
*/
sf_cgstep_close();
} else {
sf_solver_reg(fatomo_lop,sf_cgstep,sf_igrad2_lop,2*nt,nt,nrhs,ds,rhs,stiter,eps,"verb",verb,"end");
sf_cgstep_close();
}
/* line search */
gama = 1.;
for (count=0; count < 10; count++) {
/* update slowness */
for (it=0; it < nt; it++) {
if (k == NULL || k[it] != 1)
temps[it] = (s[it]+gama*ds[it])*(s[it]+gama*ds[it])/s[it];
}
/* forward fast-marching for stencil time */
fastmarch_init(n[2],n[1],n[0]);
i = 0;
for (is=0; is < nshot; is++) {
fastmarch(t[is],temps,flag,plane,
n[2],n[1],n[0],o[2],o[1],o[0],d[2],d[1],d[0],
source[is][2],source[is][1],source[is][0],1,1,1,order);
for (it=0; it < nt; it++) {
if (m[is][it] == 1) {
rhs[i] = t0[i]-t[is][it];
i++;
}
}
}
fastmarch_close();
rhsnorm = cblas_snrm2(nrhs,rhs,1);
rate = rhsnorm/rhsnorm1;
if (rate < 1.) {
for (it=0; it < nt; it++) {
s[it] = temps[it];
}
rhsnorm1 = rhsnorm;
rate = rhsnorm1/rhsnorm0;
break;
}
gama *= 0.5;
}
if (count == 10) {
sf_warning("Line-search Failure. Iteration terminated at %d of %d.",iter+1,niter);
sf_warning("Dimensions for GRAD and NORM need to be fixed before read.");
break;
}
if (l1norm)
sf_warning("L1 misfit after iteration %d of %d: %g (line-search %d)",iter+1,niter,rate,count);
else
sf_warning("L2 misfit after iteration %d of %d: %g (line-search %d)",iter+1,niter,rate,count);
if (grad != NULL) sf_floatwrite(ds,nt,grad);
if (norm != NULL) sf_floatwrite(&rate,1,norm);
}
/* convert to velocity */
if (velocity) {
for (it=0; it < nt; it++) {
s[it] = 1./sqrtf(s[it]);
}
}
sf_floatwrite(s,nt,sout);
break;
}
exit(0);
}
void dsr2_init(int nz1, float dz1 /* depth */,
int nh1, float dh1, float h01 /* half-offset */,
int nx1, float dx1, float x01 /* midpoint */,
int nu1, float du, float u0 /* slowness grid */,
int ntx, int nth /* taper size */,
int nr1 /* number of references */,
int npad /* padding on nh */)
/*< initialize >*/
{
int ix, ih, iu;
int jx, jh;
float x, h;
float kx, kh, k;
float dx, dh;
float x0, h0;
nz = nz1;
dz = dz1;
nx = nx1;
dx = 2.0*SF_PI/(nx*dx1);
x0 = -SF_PI/ dx1 ;
nh = nh1;
nh2 = nh+npad;
dh = 2.0*SF_PI/(nh2*dh1);
h0 = -SF_PI/ dh1 ;
nu = nu1;
nrmax = nr1;
fft2_init(nh2,nx);
/* allocate workspace */
sz = sf_floatalloc2 (nrmax,nz); /* reference slowness */
sm = sf_floatalloc2 (nrmax,nz); /* reference slowness squared*/
nr = sf_intalloc ( nz); /* number of reference slownesses */
qq = sf_floatalloc2 (nh,nu); /* image */
ks = sf_floatalloc2 (nh2,nx); /* source wavenumber */
kr = sf_floatalloc2 (nh2,nx); /* receiver wavenumber */
is = sf_intalloc2 (nh, nx); /* source reference */
ir = sf_intalloc2 (nh, nx); /* receiver reference */
ii = sf_intalloc (nx); /* midpoint reference */
pk = sf_complexalloc2 (nh2,nx); /* padded wavefield */
wx = sf_complexalloc2 (nh, nx); /* x wavefield */
wk = sf_complexalloc2 (nh2,nx); /* k wavefield */
ms = sf_intalloc2 (nh, nx); /* MRS map source */
mr = sf_intalloc2 (nh, nx); /* MRS map receiver */
ma = sf_floatalloc2 (nh, nx); /* MRS mask */
skip = sf_boolalloc3 (nrmax,nrmax,nz); /* skip slowness combination */
/* precompute wavenumbers */
for (ix=0; ix<nx; ix++) {
jx = (ix < nx/2)? ix + nx/2: ix - nx/2;
kx = x0 + jx*dx;
x = x01 + ix*dx1;
iu = 0.5+(x-u0)/du;
if (iu < 0) iu=0;
else if (iu >= nu) iu=nu-1;
ii[ix] = iu;
for (ih=0; ih<nh; ih++) {
h = h01 + ih*dh1;
iu = 0.5+(x-h-u0)/du;
if (iu < 0) iu=0;
else if (iu >= nu) iu=nu-1;
is[ix][ih] = iu;
iu = 0.5+(x+h-u0)/du;
if (iu < 0) iu=0;
else if (iu >= nu) iu=nu-1;
ir[ix][ih] = iu;
}
for (ih=0; ih<nh2; ih++) {
jh = (ih < nh2/2)? ih + nh2/2: ih - nh2/2;
kh = h0 + jh*dh;
k = 0.5*(kx-kh);
ks[ix][ih] = k*k;
k = 0.5*(kx+kh);
kr[ix][ih] = k*k;
}
}
/* precompute taper array */
taper2_init(nx,nh,ntx,nth,true,false);
mms = sf_fslice_init(nh*nx,nz,sizeof(int));
mmr = sf_fslice_init(nh*nx,nz,sizeof(int));
}
/*------------------------------------------------------------*/
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]; );
}
}
}