int main(int argc, char* argv[])
{
bool velocity, sym, escvar;
int is, n[3], im, nm, order, nshot, ndim, two, na, nb;
int nt, nt1, nr, ir, it, i, ia, ib;
float t, dt, da=0., a0, amax, db=0., b0, bmax, v0;
float x[3], p[3], d[3], o[3], **traj, *slow, **s, *a, *b;
raytrace rt;
sf_file shots, vel, rays, angles;
sf_init (argc,argv);
vel = sf_input("in");
rays = sf_output("out");
/* get 2-D grid parameters */
if (!sf_histint(vel,"n1",n)) sf_error("No n1= in input");
if (!sf_histint(vel,"n2",n+1)) sf_error("No n2= in input");
if (!sf_histint(vel,"n3",n+2)) sf_error("No n3= in input");
if (!sf_histfloat(vel,"d1",d)) sf_error("No d1= in input");
if (!sf_histfloat(vel,"d2",d+1)) sf_error("No d2= in input");
if (!sf_histfloat(vel,"d3",d+2)) sf_error("No d3= in input");
if (!sf_histfloat(vel,"o1",o)) o[0]=0.;
if (!sf_histfloat(vel,"o2",o+1)) o[1]=0.;
if (!sf_histfloat(vel,"o3",o+2)) o[2]=0.;
/* additional parameters */
if(!sf_getbool("vel",&velocity)) velocity=true;
/* If y, input is velocity; if n, slowness */
if(!sf_getint("order",&order)) order=4;
/* Interpolation order */
if (!sf_getint("nt",&nt)) sf_error("Need nt=");
/* Number of time steps */
if (!sf_getfloat("dt",&dt)) sf_error("Need dt=");
/* Sampling in time */
if (!sf_getbool("sym",&sym)) sym=true;
/* if y, use symplectic integrator */
if(!sf_getbool("escvar",&escvar)) escvar=false;
/* If y - output escape values, n - trajectories */
/* get shot locations */
if (NULL != sf_getstring("shotfile")) {
/* file with shot locations */
shots = sf_input("shotfile");
if (!sf_histint(shots,"n1",&ndim) || 3 != ndim)
sf_error("Must have n1=2 in shotfile");
if (!sf_histint(shots,"n2",&nshot))
sf_error("No n2= in shotfile");
s = sf_floatalloc2 (ndim,nshot);
sf_floatread(s[0],ndim*nshot,shots);
sf_fileclose (shots);
} else {
nshot = 1;
ndim = 3;
s = sf_floatalloc2 (ndim,nshot);
if (!sf_getfloat("zshot",&s[0][0])) s[0][0]=o[0];
/* shot location in depth (if shotfile is not specified) */
if (!sf_getfloat("yshot",&s[0][1])) s[0][1]=o[1] + 0.5*(n[1]-1)*d[1];
/* shot location inline (if shotfile is not specified) */
if (!sf_getfloat("xshot",&s[0][2])) s[0][2]=o[2] + 0.5*(n[2]-1)*d[2];
/* shot location crossline (if shotfile is not specified) */
sf_warning("Shooting from z=%g, y=%g, x=%g",s[0][0],s[0][1],s[0][2]);
}
if (NULL != sf_getstring("anglefile")) {
/* file with initial angles */
angles = sf_input("anglefile");
if (!sf_histint(angles,"n1",&nr)) sf_error("No n1= in anglefile");
if (!sf_histint(angles,"n2",&two) || 2 != two) sf_error("Need n2=2 in anglefile");
a = sf_floatalloc(nr);
b = sf_floatalloc(nr);
} else {
angles = NULL;
if (!sf_getint("na",&na)) sf_error("Need na=");
/* Number of azimuths (if anglefile is not specified) */
if (!sf_getint("nb",&nb)) sf_error("Need nb=");
/* Number of inclinations (if anglefile is not specified) */
if (!sf_getfloat("a0",&a0)) a0 = 0.;
/* First azimuth angle in degrees (if anglefile is not specified) */
if (!sf_getfloat("amax",&amax)) amax=360.;
/* Maximum azimuth angle in degrees (if anglefile is not specified) */
if (!sf_getfloat("b0",&b0)) b0 = 0.;
/* First inclination angle in degrees (if anglefile is not specified) */
if (!sf_getfloat("bmax",&bmax)) bmax=180.;
/* Maximum inclination angle in degrees (if anglefile is not specified) */
/* convert degrees to radians */
a0 *= SF_PI/180.;
amax *= SF_PI/180.;
b0 *= SF_PI/180.;
bmax *= SF_PI/180.;
/* figure out angle spacing */
da = (na > 1)? (amax - a0)/(na-1) : 0.;
db = (nb > 1)? (bmax - b0)/(nb-1) : 0.;
nr = na*nb;
a = sf_floatalloc(nr);
b = sf_floatalloc(nr);
for (ir=ib=0; ib < nb; ib++) {
for (ia=0; ia < na; ia++, ir++) {
b[ir] = b0 + ib*db;
a[ir] = a0 + ia*da;
}
}
}
/* specify output dimensions */
nt1 = nt+1;
if (escvar) {
sf_putint (rays, "n1", 4);
sf_putfloat (rays, "o1", 0.0);
sf_putfloat (rays, "d1", 1.0);
sf_putstring (rays, "label1", "Escape variable");
sf_putstring (rays, "unit1", "");
if (NULL == angles) {
sf_putint (rays, "n2", na);
sf_putfloat (rays, "d2", da*180.0/SF_PI);
sf_putfloat (rays, "o2", a0*180.0/SF_PI);
sf_putstring (rays, "label2", "Azimuth");
sf_putstring (rays, "unit2", "Degrees");
sf_putint (rays, "n3", nb);
sf_putfloat (rays, "d3", db*180.0/SF_PI);
sf_putfloat (rays, "o3", b0*180.0/SF_PI);
sf_putstring (rays, "label3", "Inclination");
sf_putstring (rays, "unit3", "Degrees");
sf_putint (rays,"n4",nshot);
sf_putfloat (rays, "d4", 1.0);
sf_putfloat (rays, "o4", 0.0);
sf_putstring (rays, "label4", "Shots");
sf_putstring (rays, "unit4", "");
} else {
sf_putint (rays,"n2",nr);
sf_putfloat (rays, "d2", 1.0);
sf_putfloat (rays, "o2", 0.0);
sf_putstring (rays, "label2", "Angles");
sf_putstring (rays, "unit2", "");
sf_putint (rays,"n3",nshot);
sf_putfloat (rays, "d3", 1.0);
sf_putfloat (rays, "o3", 0.0);
sf_putstring (rays, "label3", "Shots");
sf_putstring (rays, "unit3", "");
}
} else {
sf_putint (rays,"n1",ndim);
sf_putint (rays,"n2",nt1);
sf_putint (rays,"n3",nr);
sf_putint (rays,"n4",nshot);
}
/* get slowness squared */
nm = n[0]*n[1]*n[2];
slow = sf_floatalloc(nm);
sf_floatread(slow,nm,vel);
for(im = 0; im < nm; im++){
v0 = slow[im];
slow[im] = velocity? 1./(v0*v0): v0*v0;
}
/* initialize ray tracing object */
rt = raytrace_init (3, sym, nt, dt, n, o, d, slow, order);
free (slow);
traj = sf_floatalloc2 (sym? ndim: 2*ndim,nt1);
for( is = 0; is < nshot; is++) { /* loop over shots */
/* initialize angles */
if (NULL != angles) {
sf_floatread(a,nr,angles);
sf_floatread(b,nr,angles);
}
for (ir = 0; ir < nr; ir++) { /* loop over rays */
/* initialize position */
x[0] = s[is][0];
x[1] = s[is][1];
x[2] = s[is][2];
/* initialize direction */
p[2] = +sinf(a[ir])*sinf(b[ir]);
p[1] = -cosf(a[ir])*sinf(b[ir]);
p[0] = cosf(b[ir]);
it = trace_ray (rt, x, p, traj);
if (it < 0) it = -it; /* keep side-exiting rays */
if (escvar) {
/* Write escape variables only */
sf_floatwrite (traj[it],ndim,rays); /* z, x, y */
t = it*dt; /* t */
sf_floatwrite (&t, 1, rays);
} else {
for (i=0; i < nt1; i++) {
if (0==it || it > i) {
sf_floatwrite (traj[i],ndim,rays);
} else {
sf_floatwrite (traj[it],ndim,rays);
}
}
}
}
}
exit (0);
}
int main(int argc, char* argv[])
{
off_t pos;
bool sign, half;
int nsx, nsy, nmx, nmy, nhx, nhy, nmhx, nmhy, nt;
int isx, isy, imx, imy, ihx, ihy;
float osx, osy, dsx, dsy, omx, omy, dmx, dmy, ohx, ohy, dhx, dhy, dmhx, dmhy, binx, biny;
float s_xmin, s_ymin, r_xmin, r_ymin, s_xmax, s_ymax, r_xmax, r_ymax, survey_xmin, survey_ymin, survey_xmax, survey_ymax;
char *trace, *zero;
sf_file in, out;
sf_init(argc,argv);
in = sf_input ( "in");
out = sf_output("out");
sf_warning("WARNING: This 3-D CMP sorting code is not yet ready for use--this message will be removed when it is. ");
if (!sf_histint (in,"n1",&nt)) sf_error("No n1= in input");
/* Number of samples per trace */
if (!sf_histint (in,"n2",&nhx)) sf_error("No n2= in input");
/* Number of offsets per shot gather in x-direction*/
if (!sf_histfloat(in,"o2",&ohx)) sf_error("No o2= in input");
/* First offset x-component */
if (!sf_histfloat(in,"d2",&dhx)) sf_error("No d2= in input");
/* Offset increment in x-direction */
if (!sf_histint (in,"n3",&nhy)) sf_error("No n3= in input");
/* Number of offsets per shot gather in y-direction*/
if (!sf_histfloat(in,"o3",&ohy)) sf_error("No o3= in input");
/* First offset y-component */
if (!sf_histfloat(in,"d3",&dhy)) sf_error("No d3= in input");
/* Offset increment in y-direction */
if (!sf_histint (in,"n4",&nsx)) sf_error("No n4= in input");
/* Number of sources along x-direction*/
if (!sf_histfloat(in,"d4",&dsx)) sf_error("No d4= in input");
/* Source spacing in x-direction*/
if (!sf_histfloat(in,"o4",&osx)) sf_error("No o4= in input");
/* First source x-coordinate*/
if (!sf_histint (in,"n5",&nsy)) sf_error("No n5= in input");
/* Number of sources along y-direction*/
if (!sf_histfloat(in,"d5",&dsy)) sf_error("No d5= in input");
/* Source spacing in y-direction*/
if (!sf_histfloat(in,"o5",&osy)) sf_error("No o5= in input");
/* First source y-coordinate*/
if (!sf_getfloat("binx",&binx)) sf_error("No x bin size specified. Please set binx=");
/*Number of bins along x-direction*/
if (!sf_getfloat("biny",&biny)) sf_error("No y bin size specified. Please set biny=");
/*Number of bins along y-direction*/
if (!sf_getbool("positive",&sign)) sign=true;
/* initial offset orientation:
yes is generally for off-end surveys, where the first offsets are positive.
no is generally for split-spread surveys with first negative then positive offsets. */
if (!sf_getbool("half",&half)) half=true;
/* if y, the second axis is half-offset instead of full offset*/
if (!half) {
dhx /= 2;
ohx /= 2;
dhy /= 2;
ohy /= 2;
}
s_xmin = osx;
s_ymin = osy;
s_xmax = osx+(nsx*dsx);
s_ymax = osy+(nsy*dsy);
r_xmin = s_xmin+2*ohx;
r_ymin = s_ymin+2*ohy;
r_xmax = s_xmax+2*(ohx+dhx*nhx);
r_ymax = s_ymax+2*(ohy+dhy*nhy);
if (s_xmin <= r_xmin){
survey_xmin = s_xmin;
}else{
survey_xmin = r_xmin;
}
if (s_ymin <= r_ymin){
survey_ymin = s_ymin;
}else{
survey_ymin = r_ymin;
}
if (s_xmax <= r_xmax){
survey_xmax = r_xmax;
}else{
survey_xmax = s_xmax;
}
if (s_ymax <= r_ymax){
survey_ymax = r_ymax;
}else{
survey_ymax = s_ymax;
}
dmx = (survey_xmax - survey_xmin)/binx;
dmy = (survey_ymax - survey_ymin)/biny;
omx = survey_xmin + dmx/2.;
omy = survey_ymin + dmy/2.;
nmx = binx;
nmy = biny;
nmhx = (int)(nhx*nsx/nmx);
nmhy = (int)(nhy*nsy/nmy);
dmhx = dhx;
dmhy = dhy;
sf_putint (out,"n2",nmhx);
sf_putint (out,"n3",nmhy);
sf_putfloat(out,"d2",dmhx);
sf_putfloat(out,"d3",dmhy);
sf_putint (out,"n4",nmx);
sf_putint (out,"n5",nmy);
sf_putfloat(out,"d4",dmx);
sf_putfloat(out,"d5",dmy);
sf_putfloat(out,"o4",omx);
sf_putfloat(out,"o5",omy);
sf_putstring(out,"label3","hx");
sf_putstring(out,"label4","hy");
sf_putstring(out,"label5","mx");
sf_putstring(out,"label6","my");
nt *= sf_esize(in);
trace = sf_charalloc(nt);
zero = sf_charalloc(nt);
memset(zero,0,nt);
sf_fileflush(out,in);
sf_setform( in,SF_NATIVE);
sf_setform(out,SF_NATIVE);
sf_unpipe(in,(off_t) nsx*nsy*nhx*nhy*nt);
pos = sf_tell(in);
for (isx=0; isx < nsx; isx++) {
for (isy=0; isy < nsy; isy++) {
for (ihx=0; ihx < nhx; ihx++) {
for (ihy=0; ihy < nhy; ihy++) {
imx = (int)((isx + ihx)/2.0);
imy = (int)((isy + ihy)/2.0);
if (isx >= 0 && isx < nsx && ihx < nhx) {
if (isy >= 0 && isy < nsy && ihy < nhy) {
sf_seek(in,pos+((isx*nhx+ihx)+(isy*nhy+ihy))*nt,SEEK_SET);
sf_charread(trace,nt,in);
sf_charwrite(trace,nt,out);
}
} else {
sf_charwrite(zero,nt,out);
}
}
}
}
}
exit(0);
}
int main(int argc, char* argv[])
{
char *unit, *type;
bool adj, cig, cmp;
off_t nzx;
int nt, nx, ny, ns, nh, nz, i, ix, iz, ih, is, ist, iht, ng;
float *trace, **out, **table, *stable, *rtable, **tablex, *stablex, *rtablex;
float ds, s0, x0, y0, dy, s, h, h0, dh, dx, ti, t0, t1, t2, dt, z0, dz, tau;
float aal, tx, aper;
sf_file dat, mig, tbl, der;
sf_init (argc,argv);
if (!sf_getbool("adj",&adj)) adj=true;
/* y for migration, n for modeling */
if (!sf_getbool("cmp",&cmp)) cmp=true;
/* y for CMP gather, n for shot gather */
if (adj) {
dat = sf_input("in");
mig = sf_output("out");
} else {
mig = sf_input("in");
dat = sf_output("out");
}
tbl = sf_input("table"); /* traveltime table */
der = sf_input("deriv"); /* source derivative table */
if (adj) {
if (!sf_histint(dat,"n1",&nt)) sf_error("No n1= in input");
if (!sf_histint(dat,"n2",&nh)) sf_error("No n2= in input");
if (!sf_histint(dat,"n3",&ns)) sf_error("No n3= in input");
if (!sf_histfloat(dat,"o1",&t0)) sf_error("No o1= in input");
if (!sf_histfloat(dat,"d1",&dt)) sf_error("No d1= in input");
if (!sf_histfloat(dat,"o2",&h0)) sf_error("No o2= in input");
if (!sf_histfloat(dat,"d2",&dh)) sf_error("No d2= in input");
if (!sf_histfloat(dat,"o3",&s0)) sf_error("No o3= in input");
if (!sf_histfloat(dat,"d3",&ds)) sf_error("No d3= in input");
} else {
if (!sf_getint("nt",&nt)) sf_error("Need nt="); /* time samples */
if (!sf_getint("nh",&nh)) nh=1; /* offset/receiver samples */
if (!sf_getint("ns",&ns)) ns=1; /* shot samples */
if (!sf_getfloat("t0",&t0)) t0=0.0; /* time origin */
if (!sf_getfloat("dt",&dt)) sf_error("Need dt="); /* time sampling */
if (!sf_getfloat("h0",&h0)) h0=0.0; /* offset/receiver origin */
if (!sf_getfloat("dh",&dh)) sf_error("Need dh="); /* offset/receiver sampling */
if (!sf_getfloat("s0",&s0)) s0=0.0; /* shot origin */
if (!sf_getfloat("ds",&ds)) sf_error("Need ds="); /* shot sampling */
}
if (1==nh) dh=0.0;
if (1==ns) ds=0.0;
if (!sf_histint(tbl,"n1",&nz)) sf_error("No n1= in table");
if (!sf_histint(tbl,"n2",&nx)) sf_error("No n2= in table");
if (!sf_histint(tbl,"n3",&ny)) sf_error("No n3= in table");
if (!sf_histfloat(tbl,"o1",&z0)) sf_error("No o1= in table");
if (!sf_histfloat(tbl,"d1",&dz)) sf_error("No d1= in table");
if (!sf_histfloat(tbl,"o2",&x0)) sf_error("No o2= in table");
if (!sf_histfloat(tbl,"d2",&dx)) sf_error("No d2= in table");
if (!sf_histfloat(tbl,"o3",&y0)) sf_error("No o3= in table");
if (!sf_histfloat(tbl,"d3",&dy)) sf_error("No d3= in table");
if (!sf_getfloat("tau",&tau)) tau=0.;
/* static time-shift (in second) */
if (!sf_getfloat("aperture",&aper)) aper=90.;
/* migration aperture (in degree) */
if (!sf_getfloat("antialias",&aal)) aal=1.0;
/* antialiasing */
if (!sf_getbool("cig",&cig)) cig=false;
/* y - output common offset/receiver gathers */
ng = cig? nh: 1;
if (adj) {
sf_putint(mig,"n1",nz);
sf_putint(mig,"n2",nx);
sf_putfloat(mig,"o1",z0);
sf_putfloat(mig,"d1",dz);
sf_putfloat(mig,"o2",x0);
sf_putfloat(mig,"d2",dx);
sf_putstring(mig,"label1","Depth");
sf_putstring(mig,"label2","Lateral");
unit = sf_histstring(dat,"unit2");
if (NULL != unit) sf_putstring(mig,"unit1",unit);
if (cig) {
sf_putint(mig,"n3",nh);
sf_putfloat(mig,"o3",h0);
sf_putfloat(mig,"d3",dh);
if (cmp)
sf_putstring(mig,"label3","Offset");
else
sf_putstring(mig,"label3","Receiver");
if (NULL != unit) sf_putstring(mig,"unit3",unit);
} else {
sf_putint(mig,"n3",1);
}
} else {
sf_putint(dat,"n1",nt);
sf_putint(dat,"n2",nh);
sf_putint(dat,"n3",ns);
sf_putfloat(dat,"o1",t0);
sf_putfloat(dat,"d1",dt);
sf_putfloat(dat,"o2",h0);
sf_putfloat(dat,"d2",dh);
sf_putfloat(dat,"o3",s0);
sf_putfloat(dat,"d3",ds);
sf_putstring(dat,"label1","Time");
sf_putstring(dat,"unit1","s");
if (cmp)
sf_putstring(dat,"label2","Offset");
else
sf_putstring(dat,"label2","Receiver");
sf_putstring(dat,"label3","Shot");
}
nzx = (off_t) nz* (off_t) nx;
/* read traveltime table */
table = sf_floatalloc2(nzx,ny);
sf_floatread(table[0],nzx*ny,tbl);
sf_fileclose(tbl);
/* read derivative table */
tablex = sf_floatalloc2(nzx,ny);
sf_floatread(tablex[0],nzx*ny,der);
sf_fileclose(der);
out = sf_floatalloc2(nzx,ng);
trace = sf_floatalloc(nt);
stable = sf_floatalloc(nzx);
stablex = sf_floatalloc(nzx);
rtable = sf_floatalloc(nzx);
rtablex = sf_floatalloc(nzx);
if (NULL == (type = sf_getstring("type"))) type="hermit";
/* type of interpolation (default Hermit) */
/* initialize interpolation */
tinterp_init(nzx,dy);
/* initialize summation */
kirmig_init(nt,dt,t0);
if (adj) {
memset (out[0], 0, nzx*ng*sizeof(float));
} else {
sf_floatread(out[0],nzx,mig);
}
for (is=0; is < ns; is++) { /* shot */
s = s0+is*ds;
/* cubic Hermite spline interpolation */
ist = (s-y0)/dy;
if (ist <= 0) {
for (i=0; i < nzx; i++) {
stable[i] = table[0][i];
stablex[i] = tablex[0][i];
}
} else if (ist >= ny-1) {
for (i=0; i < nzx; i++) {
stable[i] = table[ny-1][i];
stablex[i] = tablex[ny-1][i];
}
} else {
switch (type[0]) {
case 'l': /* linear */
tinterp_linear(stable, s-ist*dy-y0,table[ist],table[ist+1]);
dinterp_linear(stablex,s-ist*dy-y0,table[ist],table[ist+1]);
break;
case 'p': /* partial */
tinterp_partial(stable, s-ist*dy-y0,nz,nx,dx,table[ist],table[ist+1]);
dinterp_partial(stablex,s-ist*dy-y0,nz,nx,dx,table[ist],table[ist+1]);
break;
case 'h': /* hermit */
tinterp_hermite(stable, s-ist*dy-y0,table[ist],table[ist+1],tablex[ist],tablex[ist+1]);
dinterp_hermite(stablex,s-ist*dy-y0,table[ist],table[ist+1],tablex[ist],tablex[ist+1]);
break;
}
}
for (ih=0; ih < nh; ih++) { /* offset/receiver */
h = h0+ih*dh;
/* cubic Hermite spline interpolation */
iht = cmp? (s+h-y0)/dy: (h-y0)/dy;
if (iht <= 0) {
for (i=0; i < nzx; i++) {
rtable[i] = table[0][i];
rtablex[i] = tablex[0][i];
}
} else if (iht >= ny-1) {
for (i=0; i < nzx; i++) {
rtable[i] = table[ny-1][i];
rtablex[i] = tablex[ny-1][i];
}
} else {
switch (type[0]) {
case 'l': /* linear */
tinterp_linear(rtable, cmp? s+h-iht*dy-y0: h-iht*dy-y0,table[iht],table[iht+1]);
dinterp_linear(rtablex,cmp? s+h-iht*dy-y0: h-iht*dy-y0,table[iht],table[iht+1]);
break;
case 'p': /* partial */
tinterp_partial(rtable, cmp? s+h-iht*dy-y0: h-iht*dy-y0,nz,nx,dx,table[iht],table[iht+1]);
dinterp_partial(rtablex,cmp? s+h-iht*dy-y0: h-iht*dy-y0,nz,nx,dx,table[iht],table[iht+1]);
break;
case 'h': /* hermit */
tinterp_hermite(rtable, cmp? s+h-iht*dy-y0: h-iht*dy-y0,table[iht],table[iht+1],tablex[iht],tablex[iht+1]);
dinterp_hermite(rtablex,cmp? s+h-iht*dy-y0: h-iht*dy-y0,table[iht],table[iht+1],tablex[iht],tablex[iht+1]);
break;
}
}
if (adj) {
/* read trace */
sf_floatread (trace,nt,dat);
doubint(nt,trace);
} else {
for (i=0; i < nt; i++) {
trace[i]=0.;
}
}
#ifdef _OPENMP
#pragma omp parallel for private(iz,ix,t1,t2,ti,tx)
#endif
for (i=0; i < nzx; i++) {
iz = i%nz;
ix = (i-iz)/nz;
/* aperture (cone angle) */
if (cmp) {
if (h >= 0.) {
if (atanf((s-x0-ix*dx)/(iz*dz))*180./SF_PI > aper) continue;
if (atanf((x0+ix*dx-s-h)/(iz*dz))*180./SF_PI > aper) continue;
} else {
if (atanf((s+h-x0-ix*dx)/(iz*dz))*180./SF_PI > aper) continue;
if (atanf((x0+ix*dx-s)/(iz*dz))*180./SF_PI > aper) continue;
}
} else {
if (h-s >= 0.) {
if (atanf((s-x0-ix*dx)/(iz*dz))*180./SF_PI > aper) continue;
if (atanf((x0+ix*dx-h)/(iz*dz))*180./SF_PI > aper) continue;
} else {
if (atanf((h-x0-ix*dx)/(iz*dz))*180./SF_PI > aper) continue;
if (atanf((x0+ix*dx-s)/(iz*dz))*180./SF_PI > aper) continue;
}
}
t1 = stable[i];
t2 = rtable[i];
ti = t1+t2+tau;
tx = SF_MAX(fabsf(stablex[i]*ds),fabsf(rtablex[i]*dh));
pick(adj,ti,tx*aal,out[cig ? ih : 0]+i,trace);
}
if (!adj) {
doubint(nt,trace);
sf_floatwrite (trace,nt,dat);
}
} /* ih */
}
if (adj) sf_floatwrite(out[0],nzx*ng,mig);
exit(0);
}
int main (int argc,char* argv[])
{
int i, ip, n1, n2, np, ndim, order, n123, *pp, n[2], box[2], *shift[2], b;
float o1, o2, d1, d2, slow, *dd, **pts, *vv, *h, *bin, *vor, d[2], *rect[2];
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);
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_lin_int, 2, 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);
box[0] = 1;
for (i=0; i < n123; i++) {
/* normalize by the fold */
if (vv[i] > FLT_EPSILON) bin[i] /=vv[i];
vv[i]=0.0f;
pp[i]=0;
b = ceilf(dd[i]);
if (b > box[0]) box[0] = b;
}
box[1] = box[0];
/* 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[0] = dd; shift[0] = pp;
rect[1] = dd; shift[1] = pp;
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[])
{
float *tabout ;
float oh, os, oy, or, dh, ds, dy, dr ;
float sloc, hloc, yloc, rloc ;
int nh, ns, ny, nr ;
int mo, ms, my, mr ;
int i, j, k, l ;
sf_file inp, out;
sf_init( argc, argv ) ;
inp = sf_input("in");
out = sf_output("out");
if (SF_FLOAT != sf_gettype(inp)) sf_error("Need float input");
if (!sf_histint(inp, "n1" , &nh)) sf_error("No n1= in input");
if (!sf_histint(inp, "n2" , &ns)) sf_error("No n2= in input");
if (!sf_histfloat(inp, "o1" , &oh)) sf_error("No o1= in input");
if (!sf_histfloat(inp, "o2" , &os)) sf_error("No o2= in input");
if (!sf_histfloat(inp, "d1" , &dh)) sf_error("No d1= in input");
if (!sf_histfloat(inp, "d2" , &ds)) sf_error("No d2= in input");
if (!sf_getint("mo", &mo)) sf_error("Need mo=");
/* offset parameter, a constant offset line will appear in the output every o offset */
if (!sf_getint("ms", &ms)) sf_error("Need ms=");
/* source parameter, a constant source line will appear in the output every s source */
if (!sf_getint("my", &my)) sf_error("Need my=");
/* midpoint parameter, a constant midpoint line will appear in the output every y midpoint */
if (!sf_getint("mr", &mr)) sf_error("Need mr=");
/* receiver parameter, a constant receiver line will appear in the output every r receiver */
ny = 2 * (ns - 1) + nh ;
oy = oh/2 ;
dy = dh/2 ;
nr = ns - 1 + nh ;
or = os + oh ;
dr = dh ;
tabout = sf_floatalloc( nh * ns);
for ( k = 0 ; k < nh * ns ; k++)
tabout[k] = 1.0f;
for ( i = 0 ; i < nh ; i ++ ) {
for ( j = 0 ; j < ns ; j ++ ) {
hloc = oh + i * dh ;
sloc = os + j * ds ;
yloc = sloc + hloc/2 ;
rloc = sloc + hloc ;
k = (int) floorf( (yloc - oy)/dy + 0.5 ) ;
l = (int) floorf( (rloc - or)/dr + 0.5 ) ;
assert( k >= 0 && k < ny ) ;
assert( l >= 0 && l < nr ) ;
if ( !(i % mo) || !(j % ms) || !(k % my) || !(l % mr) ) {
tabout[nh * j + i] = 0.0 ;
}
}
}
sf_floatwrite(tabout, nh * ns, out);
exit(0);
}
int main(int argc, char* argv[])
{
int i1, n1, i2, m2, m3, n2, n, order, ng, ig, i0, w, nw, iw, jw, nw1, nw2;
int wi;
float *coord, **inp, *out, **oth, o1, d1, o2, d2, g0, dg, g;
float *corr, *win1, *win2, a, b, a2, b2, ab, h, dw;
bool taper, diff, verb, shift;
sf_file in, warped, other;
sf_init (argc, argv);
in = sf_input("in");
warped = sf_output("out");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if(!sf_histint(in,"n1",&n1)) sf_error ("No n1= in input");
if(!sf_histfloat(in,"d1",&d1)) sf_error ("No d1= in input");
if(!sf_histfloat(in,"o1",&o1)) o1 = 0.;
if(!sf_histint(in,"n2",&m2)) m2 = 1;
if(!sf_histint(in,"n3",&m3)) m3 = 1;
if (!sf_getint("ng",&ng)) ng=1;
/* number of gamma values */
if (!sf_getfloat("g0",&g0)) sf_error("Need g0=");
/* gamma origin */
if (!sf_getfloat("dg",&dg)) dg=g0;
/* gamma sampling */
if (!sf_getbool("shift",&shift)) shift=false;
/* use shift instead of stretch */
other = sf_input("other");
if(!sf_histint(other,"n1",&n2)) sf_error ("No n1= in other");
if(!sf_histfloat(other,"d1",&d2)) sf_error ("No d1= in other");
if(!sf_histfloat(other,"o1",&o2)) o2 = 0.;
if (m3 > 1) {
sf_putint (warped,"n4",ng);
sf_putfloat(warped,"d4",dg);
sf_putfloat(warped,"o4",g0);
} else if (m2 > 1) {
sf_putint (warped,"n3",ng);
sf_putfloat(warped,"d3",dg);
sf_putfloat(warped,"o3",g0);
} else {
sf_putint (warped,"n2",ng);
sf_putfloat(warped,"d2",dg);
sf_putfloat(warped,"o2",g0);
}
m2 *= m3;
n = n2*m2;
if(!sf_getint("accuracy",&order)) {
/* [1-4] interpolation accuracy */
order = 2;
} else if (order < 1 || order > 4) {
sf_error ("accuracy must be between 1 and 4");
}
order *= 2;
if (!sf_getint("nw",&nw)) sf_error ("Need nw=");
/* number of windows */
if (!sf_getint("w",&w)) sf_error ("Need w=");
/* window size */
if (!sf_getfloat("h",&h)) h=0.5*(w-1);
/* window overlap */
if (!sf_getbool("taper",&taper)) taper=true;
/* window tapering */
if (!sf_getbool("verb",&verb)) verb=true;
/* w */
if (!sf_getbool("diff",&diff)) diff=false;
/* if y, compute difference power insted of correlation */
dw = (n2-w)/(nw-1.);
nw1 = (0.5*w+1.)/dw;
nw2 = (0.5*w-2.)/dw;
nw += nw1 + nw2;
sf_putint(warped,"n1",nw);
sf_putfloat(warped,"o1",o2+(0.5*w+1.)*d2-nw2*dw*d2);
sf_putfloat(warped,"d1",dw*d2);
window1_init (h,dw);
coord = sf_floatalloc (n2);
inp = sf_floatalloc2 (n1,m2);
out = sf_floatalloc (n2);
oth = sf_floatalloc2 (n2,m2);
corr = sf_floatalloc (nw);
win1 = sf_floatalloc (w);
win2 = sf_floatalloc (w);
win2 = sf_floatalloc (w);
sf_prefilter_init (order, n1, order*10);
for (i2=0; i2 < m2; i2++) {
sf_floatread(inp[i2],n1,in);
sf_prefilter_apply (n1, inp[i2]);
}
sf_prefilter_close();
sf_floatread(oth[0],m2*n2,other);
sf_fileclose(other);
for (ig=0; ig < ng; ig++) {
if (verb) sf_warning("scanned %d of %d",ig+1,ng);
g = g0 + ig*dg;
for (i1=0; i1 < n2; i1++) {
coord[i1] = shift? o2+i1*d2+g: (o2+i1*d2)*g;
}
sf_int1_init (coord, o1, d1, n1, sf_spline_int, order, n2);
for (i2=0; i2 < m2; i2++) {
sf_int1_lop (false,false,n1,n2,inp[i2],out);
for (iw=0; iw < nw; iw++) {
a2=0.;
b2=0.;
ab=0.;
if (iw < nw1) {
jw = 0;
wi = 0.5*(w+1.) + iw*dw;
} else if (iw >= nw-nw2) {
jw = iw-nw1;
wi = 0.5*(w+1.) + (nw-1-iw)*dw;
} else {
jw = iw-nw1;
wi = w;
}
i0 = window1_apply(jw,wi,out,taper,taper,win1);
i0 = window1_apply(jw,wi,oth[i2],taper,taper,win2);
for (i1=0; i1 < wi; i1++) {
a = win1[i1];
b = win2[i1];
ab += a*b;
a2 += a*a;
b2 += b*b;
}
corr[iw] = diff?
a2 + b2 - 2.*ab:
ab/sqrtf(a2*b2+FLT_EPSILON);
}
sf_floatwrite(corr,nw,warped);
}
}
exit (0);
}
int main(int argc, char* argv[])
{
int dim, n[SF_MAX_DIM], rect[SF_MAX_DIM], nd;
int ns, nt, nm, nx, i, ix, is, it, niter, imax;
float **slice, *pick0, *pick, *ampl;
float s0, ds, t, asum, ai, amax, ap, am, num, den, dx;
char key[6];
sf_file in, out;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
dim = sf_filedims (in,n);
if (dim < 2) sf_error("Need at least two dimensions");
nd = 1;
for (i=0; i < dim; i++) {
nd *= n[i];
if (n[i] > 1) {
snprintf(key,6,"rect%d",i+1);
if (!sf_getint(key,rect+i)) rect[i]=1;
} else {
rect[i]=1;
}
}
nt = n[0];
ns = n[1];
nm = nd/ns;
nx = nm/nt;
if (!sf_histfloat(in,"o2",&s0)) sf_error("No o2= in input");
if (!sf_histfloat(in,"d2",&ds)) sf_error("No d2= in input");
sf_putint(out,"n2",1);
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
for (i=1; i < dim-1; i++) {
n[i] = n[i+1];
}
dim--;
divn_init(dim,nm,n,rect,niter);
slice = sf_floatalloc2(nt,ns);
pick0 = sf_floatalloc(nm);
pick = sf_floatalloc(nm);
ampl = sf_floatalloc(nm);
for (ix = 0; ix < nx; ix++) {
sf_floatread (slice[0],nt*ns,in);
/* pick blind maximum */
for (it = 0; it < nt; it++) {
i = ix*nt+it;
imax = 0;
amax = 0.;
for (is = 0; is < ns; is++) {
t = slice[is][it];
if (t > amax) {
amax = t;
imax = is;
}
}
/* quadratic interpolation for sub-pixel accuracy */
if (imax > 0 && imax < ns-1) {
am = slice[imax-1][it];
ap = slice[imax+1][it];
num = 0.5*(am-ap);
den = am+ap-2.*amax;
dx = num*den/(den*den + FLT_EPSILON);
if (fabsf(dx) >= 1.) dx=0.;
ampl[i] = amax - 0.5*dx*dx*den;
pick0[i] = s0+(imax+dx)*ds;
} else {
ampl[i] = amax;
pick0[i] = s0+imax*ds;
}
}
}
/* normalize amplitudes */
asum = 0.;
for (i = 0; i < nm; i++) {
ai = ampl[i];
asum += ai*ai;
}
asum = sqrtf (asum/nm);
for(i=0; i < nm; i++) {
ampl[i] /= asum;
pick0[i] *= ampl[i];
}
divn(pick0,ampl,pick);
sf_floatwrite (pick,nm,out);
exit (0);
}
int main(int argc, char* argv[])
{
int n1, i1, n2, i2, i, hilbn, it;
bool norm;
int fft_size;
float d1, o1, mt, ee, max, freq, hilbc, *trace, *freqc, *phase, *ric, *hilb, *outtrace;
sf_file in, out;
sf_init(argc,argv);
in = sf_input ( "in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
n2 = sf_leftsize(in,1);
/* Frequency and phase*/
if (NULL == sf_getstring("tphase") || NULL == sf_getstring("tfreq")) {
if (!sf_getfloat("frequency",&freq)) {
/* peak frequency for Ricker wavelet (in Hz) */
if (!sf_getfloat("freq",&freq)) freq=0.2;
/* peak frequency for Ricker wavelet (as fraction of Nyquist) */
} else {
if (!sf_histfloat(in,"d1",&d1)) d1=1.;
freq *= 2.*d1;
}
trace = sf_floatalloc(n1);
fft_size = 2*kiss_fft_next_fast_size((n1+1)/2);
ricker_init(fft_size, 0.5*freq, 0);
for (i2=0; i2 < n2; i2++) {
sf_floatread(trace,n1,in);
sf_freqfilt(n1,trace);
sf_floatwrite(trace,n1,out);
}
} else { /*frequency and phase are time-varying*/
sf_file tpha, tfre;
if (!sf_histfloat(in,"o1",&o1)) o1=0;
if (!sf_histfloat(in,"d1",&d1)) d1=0.001;
if (!sf_getfloat("esp",&ee)) ee=0.;
/* if norm=y, stable parameter*/
if (!sf_getbool("norm",&norm)) norm=false;
tfre = sf_input ("tfreq");
tpha = sf_input ("tphase");
if (!sf_histint(tpha,"n1",&i) || i != n1) sf_error("the phase file has not same length");
if (!sf_histint(tfre,"n1",&i) || i != n1) sf_error("the frequency file has not same length");
if (!sf_getint("hiborder",&hilbn)) hilbn=6;
/* Hilbert transformer order */
if (!sf_getfloat("hibref",&hilbc)) hilbc=1.;
trace = sf_floatalloc(n1);
freqc = sf_floatalloc(n1);
phase = sf_floatalloc(n1);
outtrace= sf_floatalloc(n1);
ric = sf_floatalloc(n1);
sf_floatread(freqc,n1,tfre);
sf_floatread(phase,n1,tpha);
sf_hilbert_init(n1, hilbn, hilbc);
hilb = sf_floatalloc(n1);
for (i2=0;i2 < n2; i2++) {
sf_floatread(trace,n1,in);
for (it=0; it < n1; it++) {
outtrace[it] = 0.;
}
for (i1=0; i1 < n1; i1++) {
max = 0.;
for (it=0;it < n1; it++) {
mt=d1*(i1-it);
ric[it] = (1-2*(SF_PI*freqc[i1]*mt*SF_PI*freqc[i1]*mt))*exp(-SF_PI*freqc[i1]*mt*SF_PI*freqc[i1]*mt);
}
sf_hilbert(ric,hilb);
for (it=0; it < n1; it++) {
hilb[it] = ric[it]*cosf(phase[i1]*SF_PI/180.) + hilb[it]*sinf(phase[i1]*SF_PI/180.);
if (hilb[it] > max) max=hilb[it];
}
for (it=0;it < n1; it++) {
if (!norm) {
max = 1;
ee = 0.;
}
hilb[it] = hilb[it]*trace[i1]/(max+ee);
outtrace[it] += hilb[it];
}
}
sf_floatwrite(outtrace,n1,out);
}
}
exit(0);
}
int main(int argc, char* argv[])
{
int n2, i2, nx, ny, niter, nliter;
float x0, dx, y0, dy, a[3], **data=NULL, **pred=NULL;
bool verb;
sf_file in, out, ma;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
ma = sf_output("ma");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if (!sf_histint(in,"n1",&nx)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&ny)) sf_error("No n2= in input");
n2 = sf_leftsize(in,2);
if (!sf_histfloat(in,"d1",&dx)) sf_error("No d1= in input");
if (!sf_histfloat(in,"o1",&x0)) sf_error("No o1= in input");
if (!sf_histfloat(in,"d2",&dy)) sf_error("No d2= in input");
if (!sf_histfloat(in,"o2",&y0)) sf_error("No o2= in input");
if (!sf_getfloat("a0",&a[0])) a[0]=1.;
/* starting sharpness in xx */
if (!sf_getfloat("b0",&a[1])) a[1]=0.;
/* starting sharpness in xy */
if (!sf_getfloat("c0",&a[2])) a[2]=1.;
/* starting sharpness in yy */
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getint("nliter",&nliter)) nliter=1;
/* number of reweighting iterations */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
sf_putint(ma,"n1",3);
sf_putint(ma,"n2",1);
sf_putint(ma,"nx",nx);
sf_putfloat(ma,"dx",dx);
sf_putfloat(ma,"x0",x0);
sf_putint(ma,"ny",ny);
sf_putfloat(ma,"dy",dy);
sf_putfloat(ma,"y0",y0);
sf_fileflush(ma,in);
data = sf_floatalloc2(nx,ny);
pred = sf_floatalloc2(nx,ny);
for (i2=0; i2 < n2; i2++) {
sf_floatread(data[0],nx*ny,in);
monof2(data,pred,nliter,niter,a,nx,dx,x0,ny,dy,y0,verb);
sf_floatwrite(a,3,ma);
sf_floatwrite (pred[0],nx*ny,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 velocity_read(sf_file velocity,float *vel,sf_file wave,float theta,int ix_center)
/*< read velocity or anisotropy parameter in tilted coordinates >*/
{
float *tmpvel;
int nvel[2],ntmpvel[2];
int mig_nx, mig_nz, vel_nx, vel_nz;
float mig_dx,mig_dz,mig_ox,mig_oz;
float vel_dx,vel_dz,vel_ox,vel_oz;
int iy,ix,iz,n_block;
float tmp_x,tmp_z,tmp_wx,tmp_wz,dtmp_x,dtmp_z;
int tmp_ix,tmp_iz;
sf_histfloat(wave,"d2",&mig_dx); sf_histfloat(wave,"o2",&mig_ox); sf_histint(wave,"n2",&mig_nx);
sf_histfloat(wave,"d1",&mig_dz); sf_histfloat(wave,"o1",&mig_oz); sf_histint(wave,"n1",&mig_nz);
sf_histfloat(velocity,"d2",&vel_dx); sf_histfloat(velocity,"o2",&vel_ox); sf_histint(velocity,"n2",&vel_nx);
sf_histfloat(velocity,"d1",&vel_dz); sf_histfloat(velocity,"o1",&vel_oz); sf_histint(velocity,"n1",&vel_nz);
d3(mig_nx,mig_nz,nvel);
d3(vel_nx,vel_nz,ntmpvel);
tmpvel=sf_floatalloc(vel_nz*vel_nx);
if (theta >=0)
{
for(iy=0;iy<1;iy++){ //do iy=1,ny
n_block=iy*vel_nx;
sf_seek(velocity,n_block*vel_nz*sizeof(float),SEEK_SET);
sf_floatread(tmpvel,vel_nz*vel_nx,velocity);
for(ix=0;ix<mig_nx;ix++){
dtmp_x=ix*mig_dx-(ix_center-1.0)*mig_dx;
for(iz=0;iz<mig_nz;iz++){
dtmp_z=iz*mig_dz;
tmp_x=mig_ox+dtmp_x*cos(theta)+dtmp_z*sin(theta);
tmp_x=(tmp_x-vel_ox)/vel_dx;
tmp_ix=(int)(tmp_x); tmp_wx=tmp_x-tmp_ix;
if (tmp_x <0){
tmp_ix=0; tmp_wx=0.5;
}
if (tmp_ix >= vel_nx-1 ){
tmp_ix=vel_nx-2; tmp_wx=0.5;
}
tmp_z=mig_oz-dtmp_x*sin(theta)+dtmp_z*cos(theta);
tmp_z=(tmp_z- vel_oz)/vel_dz;
tmp_iz=(int)(tmp_z); tmp_wz=tmp_z-tmp_iz;
if (tmp_z < 0){
tmp_iz=0; tmp_wz=0.5;
}
if (tmp_iz >= vel_nz-1 ){
tmp_iz=vel_nz-2; tmp_wz=0.5;
}
vel[i3(iy,ix,iz,nvel)]=tmpvel[i3(0,tmp_ix,tmp_iz,ntmpvel)]*(1-tmp_wz)*(1-tmp_wx)+
tmpvel[i3(0,tmp_ix,tmp_iz+1,ntmpvel)]*tmp_wz*(1-tmp_wx) +
tmpvel[i3(0,tmp_ix+1,tmp_iz,ntmpvel)]*(1-tmp_wz)*tmp_wx +
tmpvel[i3(0,tmp_ix+1,tmp_iz+1,ntmpvel)]*tmp_wz*tmp_wx;
}
}
}
}
else
{
theta=-theta;
for(iy=0;iy<1;iy++){
n_block=iy*vel_nx;
sf_seek(velocity,n_block*vel_nz*sizeof(float),SEEK_SET);
sf_floatread(tmpvel,vel_nz*vel_nx,velocity);
for(ix=mig_nx-1;ix>=0;ix--){
dtmp_x=(mig_nx-1-ix)*mig_dx-(ix_center-1)*mig_dx;
for(iz=0;iz<mig_nz;iz++){
dtmp_z=iz*mig_dz;
tmp_x=mig_ox-dtmp_x*cos(theta)-dtmp_z*sin(theta);
tmp_x=(tmp_x-vel_ox)/vel_dx;
tmp_ix=(int)(tmp_x); tmp_wx=tmp_x-tmp_ix;
if (tmp_x <0){
tmp_ix=0; tmp_wx=0.5;
}
if (tmp_ix >= vel_nx-1 ){
tmp_ix=vel_nx-2; tmp_wx=0.5;
}
tmp_z=mig_oz-dtmp_x*sin(theta)+dtmp_z*cos(theta);
tmp_z=(tmp_z-vel_oz)/vel_dz;
tmp_iz=(int)(tmp_z); tmp_wz=tmp_z-tmp_iz;
if (tmp_z < 0){
tmp_iz=0; tmp_wz=0.5;
}
if (tmp_iz >= vel_nz-1 ){
tmp_iz=vel_nz-2; tmp_wz=0.5;
}
vel[i3(iy,(mig_nx-1)-ix,iz,nvel)]=tmpvel[i3(0,tmp_ix,tmp_iz,ntmpvel)]*(1-tmp_wz)*(1-tmp_wx)+
tmpvel[i3(0,tmp_ix,tmp_iz+1,ntmpvel)]*tmp_wz*(1-tmp_wx) +
tmpvel[i3(0,tmp_ix+1,tmp_iz,ntmpvel)]*(1-tmp_wz)*tmp_wx +
tmpvel[i3(0,tmp_ix+1,tmp_iz+1,ntmpvel)]*tmp_wz*tmp_wx;
}
}
}
}
free(tmpvel);
}
int main (int argc, char* argv[])
{
fint1 nmo;
bool half, squared, slow;
int ix,ih,it,iv, nt,nx,nw, nh, nh2, m, CDPtype, mute, *mask, nv, *fold;
float dt, t0, h0,dh,h, dy, str, v0,dv,v;
float **traces, *trace, *off, *stack;
double *dstack;
mapfunc nmofunc;
sf_file cmp, stk, offset, msk;
sf_init (argc,argv);
cmp = sf_input("in");
stk = sf_output("out");
nmofunc = nmo_map;
if (SF_FLOAT != sf_gettype(cmp)) sf_error("Need float input");
if (!sf_histint (cmp,"n1",&nt)) sf_error("No n1= in input");
if (!sf_histfloat(cmp,"d1",&dt)) sf_error("No d1= in input");
if (!sf_histfloat(cmp,"o1",&t0)) sf_error("No o1= in input");
if (!sf_histint (cmp,"n2",&nh)) sf_error("No n2= in input");
nx = sf_leftsize(cmp,2);
if (!sf_getbool("half",&half)) half=true;
/* if y, the second axis is half-offset instead of full offset */
if (!sf_getfloat("str",&str)) str=0.5;
/* maximum stretch allowed */
if (!sf_getint("mute",&mute)) mute=12;
/* mute zone */
if (!sf_getint("nv",&nv)) sf_error("Need nv=");
/* number of velocities */
if (!sf_getfloat("v0",&v0)) sf_error("Need v0=");
/* first velocity */
if (!sf_getfloat("dv",&dv)) sf_error("Need dv=");
/* step in velocity */
sf_putint(stk,"n2",nv);
sf_putfloat(stk,"o2",v0);
sf_putfloat(stk,"d2",dv);
CDPtype=1;
if (NULL != sf_getstring("offset")) {
offset = sf_input("offset");
if (SF_FLOAT != sf_gettype(offset)) sf_error("Need float offset");
nh2 = sf_filesize(offset);
if (nh2 != nh && nh2 != nh*nx) sf_error("Wrong dimensions in offset");
off = sf_floatalloc(nh2);
sf_floatread (off,nh2,offset);
sf_fileclose(offset);
} else {
if (!sf_histfloat(cmp,"d2",&dh)) sf_error("No d2= in input");
if (!sf_histfloat(cmp,"o2",&h0)) sf_error("No o2= in input");
if (sf_histfloat(cmp,"d3",&dy) && !sf_getint("CDPtype",&CDPtype)) {
CDPtype=half? 0.5+dh/dy : 0.5+0.5*dh/dy;
if (CDPtype < 1) {
CDPtype=1;
} else if (1 != CDPtype) {
sf_histint(cmp,"CDPtype",&CDPtype);
sf_warning("CDPtype=%d",CDPtype);
}
}
nh2 = nh;
off = sf_floatalloc(nh2);
for (ih = 0; ih < nh; ih++) {
off[ih] = h0 + ih*dh;
}
offset = NULL;
}
if (NULL != sf_getstring("mask")) {
msk = sf_input("mask");
if (SF_INT != sf_gettype(msk)) sf_error("Need integer mask");
nh2 = sf_filesize(msk);
if (nh2 != nh && nh2 != nh*nx) sf_error("Wrong dimensions in mask");
mask = sf_intalloc(nh2);
sf_intread (mask,nh2,msk);
sf_fileclose(msk);
} else {
msk = NULL;
mask = NULL;
}
if (!sf_getbool("slowness",&slow)) slow=false;
/* if y, use slowness instead of velocity */
if (!sf_getbool("squared",&squared)) squared=false;
/* if y, the slowness or velocity is squared */
if (!sf_getfloat ("h0",&h0)) h0=0.;
/* reference offset */
if (half) h0 *= 2.;
if (!sf_getint("extend",&nw)) nw=4;
/* trace extension */
traces = sf_floatalloc2(nt,nh);
trace = sf_floatalloc(nt);
stack = sf_floatalloc(nt);
fold = sf_intalloc(nt);
dstack = (double*) sf_alloc(nt,sizeof(double));
nmo = fint1_init (nw, nt, mute);
for (ix = 0; ix < nx; ix++) {
sf_warning("CMP %d of %d;",ix+1,nx);
sf_floatread (traces[0],nt*nh,cmp);
for (iv=0; iv < nv; iv++) {
v = v0+iv*dv;
if (!squared) v *=v;
for (it=0; it < nt; it++) {
dstack[it] = 0.0;
fold[it] = 0;
}
for (ih = 0; ih < nh; ih++) {
/* skip dead traces */
if (NULL != msk) {
m = (nh2 == nh)? mask[ih] + (dh/CDPtype)*(ix%CDPtype) :
mask[ix*nh+ih];
if (0==m) continue;
}
for (it=0; it < nt; it++) {
trace[it] = traces[ih][it];
}
fint1_set(nmo,trace);
h = (nh2 == nh)? off[ih] + (dh/CDPtype)*(ix%CDPtype) :
off[ix*nh+ih];
if (half) h *= 2;
h = h*h - h0*h0;
v2 = slow ? h*v : h/v;
stretch(nmo,nmofunc,nt,dt,t0,nt,dt,t0,trace,str);
for (it=0; it < nt; it++) {
if (trace[it] != 0.0f) {
fold[it]++;
dstack[it] += trace[it];
}
}
}
for (it=0; it < nt; it++) {
if (fold[it] > 0) {
stack[it] = dstack[it]/fold[it];
} else {
stack[it] = 0.0f;
}
}
sf_floatwrite (stack,nt,stk);
}
}
sf_warning(".");
exit (0);
}
int main(int argc, char* argv[])
{
bool verb, adj, hessian;
int n1, n2, nf, i;
float df, of;
sf_complex **img, *coe0, *coe, *dx, *dr;
int iter, niter, cgiter, count;
float rhsnorm, rhsnorm0, rhsnorm1, rate, gamma;
char *what;
sf_file in, out, image, coef, grad;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (NULL == (what = sf_getstring("what"))) what="tomo";
/* what to compute (default tomography) */
switch (what[0]) {
case 'l': /* linear operator */
if (!sf_getbool("adj",&adj)) adj=false;
/* adjoint flag (for what=linear) */
/* read image */
if (NULL == sf_getstring("image"))
sf_error("Need image image=");
image = sf_input("image");
if (!sf_histint(image,"n1",&n1)) sf_error("No n1 in image.");
if (!sf_histint(image,"n2",&n2)) sf_error("No n2 in image.");
if (!sf_histint(image,"n3",&nf)) sf_error("No n3 in image.");
if (!sf_histfloat(image,"o3",&of)) sf_error("No o3 in image.");
if (!sf_histfloat(image,"d3",&df)) sf_error("No d3 in image.");
img = NULL;
/* read coefficients */
if (NULL == sf_getstring("coef"))
sf_error("Need coefficients coef=");
coef = sf_input("coef");
coe0 = sf_complexalloc(n1*n2*2);
sf_complexread(coe0,n1*n2*2,coef);
sf_fileclose(coef);
/* allocate temporary memory */
dx = sf_complexalloc(n1*n2*2);
dr = sf_complexalloc(n1*n2*nf);
/* read input and write output header */
if (adj) {
sf_complexread(dr,n1*n2*nf,in);
sf_putint(out,"n3",2);
} else {
sf_complexread(dx,n1*n2*2,in);
sf_putint(out,"n3",nf);
}
/* initialize operator */
freqmig0_init(n1,n2, of,df,nf, img);
/* set operator */
freqmig0_set(coe0);
/* linear operator */
if (adj) {
freqmig0_oper(true,false,n1*n2*2,n1*n2*nf,dx,dr);
} else {
freqmig0_oper(false,false,n1*n2*2,n1*n2*nf,dx,dr);
}
/* write output */
if (adj) {
sf_complexwrite(dx,n1*n2*2,out);
} else {
sf_complexwrite(dr,n1*n2*nf,out);
}
break;
case 't': /* tomography */
/* read model dimension */
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 initial guess */
coe0 = sf_complexalloc(n1*n2*2);
sf_complexread(coe0,n1*n2*2,in);
/* read image */
if (NULL == sf_getstring("image"))
sf_error("Need image image=");
image = sf_input("image");
if (!sf_histint(image,"n3",&nf)) sf_error("No n3 in image.");
if (!sf_histfloat(image,"o3",&of)) sf_error("No o3 in image.");
if (!sf_histfloat(image,"d3",&df)) sf_error("No d3 in image.");
img = sf_complexalloc2(n1*n2,nf);
sf_complexread(img[0],n1*n2*nf,image);
sf_fileclose(image);
/* allocate temporary memory */
dx = sf_complexalloc(n1*n2*2);
dr = sf_complexalloc(n1*n2*nf);
coe = sf_complexalloc(n1*n2*2);
if (!sf_getint("niter",&niter)) niter=5;
/* number of inversion iterations */
if (!sf_getint("cgiter",&cgiter)) cgiter=10;
/* number of conjugate-gradient iterations */
if (!sf_getbool("hessian",&hessian)) hessian=false;
/* if y, exact Hessian; n, Gauss-Newton */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
/* output gradient at each iteration */
if (NULL != sf_getstring("grad")) {
grad = sf_output("grad");
sf_putint(grad,"n4",niter);
} else {
grad = NULL;
}
/* initialize */
freqmig0_init(n1,n2, of,df,nf, img);
rhsnorm0 = freqmig0_cost(coe0,dr);
rhsnorm = rhsnorm0;
rhsnorm1 = rhsnorm;
rate = rhsnorm1/rhsnorm0;
sf_warning("L2 misfit after iteration 0 of %d: %g",niter,rate);
/* iterations over inversion */
for (iter=0; iter < niter; iter++) {
/* set operator */
freqmig0_set(coe0);
/* solve update */
sf_csolver(freqmig0_oper,sf_ccgstep,n1*n2*2,n1*n2*nf,dx,dr,cgiter,"verb",verb,"end");
sf_ccgstep_close();
/* output gradient */
if (grad != NULL) sf_complexwrite(dx,n1*n2*2,grad);
/* line search */
gamma = 1.;
for (count=0; count < 5; count++) {
/* update */
for (i=0; i < n1*n2; i++) {
coe[i] = coe0[i]+gamma*sf_cmplx(crealf(dx[i]),0.);
coe[n1*n2+i] = coe0[n1*n2+i]+gamma*sf_cmplx(crealf(dx[n1*n2+i]),0.);
}
/* check cost */
rhsnorm = freqmig0_cost(coe,dr);
rate = rhsnorm/rhsnorm1;
if (rate < 1.) {
for (i=0; i < n1*n2; i++) {
coe0[i] = coe[i];
coe0[n1*n2+i] = coe[n1*n2+i];
}
rhsnorm1 = rhsnorm;
rate = rhsnorm1/rhsnorm0;
break;
}
gamma *= 0.5;
}
if (count == 5) {
sf_warning("Line-search failure at iteration %d of %d.",iter+1,niter);
break;
}
sf_warning("L2 misfit after iteration %d of %d: %g (line-search %d)",iter+1,niter,rate,count);
}
/* write output */
sf_complexwrite(coe0,n1*n2*2,out);
/* clean-up */
freqmig0_close();
free(dx); free(dr);
break;
}
exit(0);
}
int main(int argc, char* argv[])
{
int nx, nt, ix, it, nz, iz, isx, isz, nxz, na;
float dt, dx, dz;
float **nxt, **old, **cur, *wav;
float ***coef, plap;
int *stmp, *s1, *s2, ik, SIZE=3;
sf_file out, vel, source, G;
sf_init(argc,argv);
out = sf_output("out");
vel = sf_input("vel"); /* velocity */
source = sf_input("in"); /* source wavlet*/
G = sf_input("G"); /* source wavlet*/
/* if (SF_FLOAT != sf_gettype(inp)) sf_error("Need float input"); */
if (SF_FLOAT != sf_gettype(vel)) sf_error("Need float input");
if (SF_FLOAT != sf_gettype(source)) sf_error("Need float input");
if (!sf_histint(vel,"n1",&nz)) sf_error("No n1= in input");
if (!sf_histfloat(vel,"d1",&dz)) sf_error("No d1= in input");
if (!sf_histint(vel,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histfloat(vel,"d2",&dx)) sf_error("No d2= in input");
if (!sf_getfloat("dt",&dt)) sf_error("Need dt input");
if (!sf_getint("nt",&nt)) sf_error("Need nt input");
if (!sf_getint("isx",&isx)) sf_error("Need isx input");
if (!sf_getint("isz",&isz)) sf_error("Need isz input");
if (!sf_histint(G,"n1",&nxz)) sf_error("No n1= in input");
if (!sf_histint(G,"n2",&na)) sf_error("No n2= in input");
if (nx*nz != nxz) sf_error("nx*nz != nxz");
sf_putint(out,"n1",nz);
sf_putfloat(out,"d1",dz);
sf_putint(out,"n2",nx);
sf_putfloat(out,"d2",dx);
sf_putint(out,"n3",nt);
sf_putfloat(out,"d3",dt);
sf_putfloat(out,"o3",0.0);
sf_warning("nt=%d",nt);
wav = sf_floatalloc(nt);
sf_floatread(wav,nt,source);
sf_warning("dt=%g",dt);
old = sf_floatalloc2(nz,nx);
cur = sf_floatalloc2(nz,nx);
nxt = sf_floatalloc2(nz,nx);
coef = sf_floatalloc3(nz,nx,na);
sf_floatread(coef[0][0],nz*nx*na,G);
stmp = sf_intalloc(SIZE);
s1 = sf_intalloc(na);
s2 = sf_intalloc(na);
for (ix=0; ix<SIZE; ix++) stmp[ix]= ix;
ik = 0;
for (ix=0; ix<SIZE; ix++){
for (iz=0; iz<SIZE; iz++){
if((stmp[ix] == 0) || (stmp[iz] == 0)) {
s1[ik]=stmp[iz];
s2[ik]=stmp[ix];
ik++;
}
}
}
if (ik+2!=na) sf_error("Stencil size mismatch!!!");
s1[ik] = 1; s1[ik+1] = -1;
s2[ik] = 1; s2[ik+1] = 1;
for (ix=0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
cur[ix][iz] = 0.0;
old[ix][iz] = 0.0;
}
}
cur[isx][isz] = wav[0];
/* propagation in time */
for (it=0; it < nt; it++) {
sf_floatwrite(cur[0],nz*nx,out);
for (ix=0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
nxt[ix][iz] = 0.0;
}
}
for (ix=2; ix < nx-2; ix++) {
for (iz=2; iz < nz-2; iz++) {
plap = 0.;
for (ik=0; ik < na; ik++) {
plap += 0.5*(coef[ik][ix][iz]*cur[ix+s2[ik]][iz+s1[ik]] +
coef[ik][ix][iz]*cur[ix-s2[ik]][iz-s1[ik]]);
}
nxt[ix][iz] = plap - old[ix][iz];
/*
nxt[ix][iz] = cur[ix][iz]*(a[ix][iz])
+ 0.5*(cur[ix][iz-1]+cur[ix][iz+1])*b1[ix][iz]
+ 0.5*(cur[ix][iz-2]+cur[ix][iz+2])*b2[ix][iz]
+ 0.5*(cur[ix-1][iz]+cur[ix+1][iz])*c1[ix][iz]
+ 0.5*(cur[ix-2][iz]+cur[ix+2][iz])*c2[ix][iz]
+ 0.5*(cur[ix+1][iz+1]+cur[ix-1][iz-1])*d1[ix][iz]
+ 0.5*(cur[ix+1][iz-1]+cur[ix-1][iz+1])*d2[ix][iz]
- old[ix][iz];
*/
}
}
for (ix=2; ix < nx-2; ix++) {
for (iz=2; iz < nz-2; iz++) {
old[ix][iz] = cur[ix][iz];
cur[ix][iz] = nxt[ix][iz];
}
}
cur[isx][isz] += wav[it];
}
exit(0);
}
int main(int argc, char *argv[])
{
bool wantwf, verb;
int ix, iz, is, it, wfit, im, ik, i, j, itau;
int ns, nx, nz, nt, wfnt, rnx, rnz, nzx, rnzx, vnx, ntau, htau, nds;
int scalet, snap, snapshot, fnx, fnz, fnzx, nk, nb;
int rectx, rectz, repeat, gpz, n, m, pad1, trunc, spx, spz;
float dt, t0, z0, dz, x0, dx, s0, ds, wfdt, srctrunc;
float dtau, tau0, tau;
int nr, ndr, nr0;
char *path1, *path2, number[5], *left, *right;
double tstart, tend;
struct timeval tim;
/*wavenumber domain tapering*/
int taper;
float *ktp;
float ktmp,kx_trs,kz_trs,thresh;
float dkx,dkz,kx0,kz0;
float kx,kz;
int nkz;
sf_complex c, **lt, **rt;
sf_complex *ww, **dd, ***dd3;
float ***img1, **img2, ***mig1, **mig2;
float *rr, **ccr, **sill, ***fwf, ***bwf;
sf_complex *cwave, *cwavem, **wave, *curr;
sf_axis at, ax, az, atau;
sf_file Fdat, Fsrc, Fimg1, Fimg2;
sf_file Ffwf, Fbwf, Fvel;
sf_file Fleft, Fright;
int cpuid, numprocs, nth, nspad, iturn;
float *sendbuf, *recvbuf;
sf_complex *sendbufc, *recvbufc;
MPI_Comm comm=MPI_COMM_WORLD;
MPI_Init(&argc, &argv);
MPI_Comm_rank(comm, &cpuid);
MPI_Comm_size(comm, &numprocs);
sf_init(argc, argv);
#ifdef _OPENMP
#pragma omp parallel
{
nth=omp_get_num_threads();
}
sf_warning(">>> Using %d threads <<<", nth);
#endif
gettimeofday(&tim, NULL);
tstart=tim.tv_sec+(tim.tv_usec/1000000.0);
if (!sf_getint("taper",&taper)) taper=0; /* tapering in the frequency domain */
if (!sf_getfloat("thresh",&thresh)) thresh=0.92; /* tapering threshold */
if(!sf_getbool("wantwf", &wantwf)) wantwf=false;
if(!sf_getbool("verb", &verb)) verb=false;
if(!sf_getint("pad1", &pad1)) pad1=1;
/* padding factor on the first axis */
if(!sf_getint("nb", &nb)) sf_error("Need nb= ");
if(!sf_getfloat("srctrunc", &srctrunc)) srctrunc=0.4;
if(!sf_getint("rectx", &rectx)) rectx=2;
if(!sf_getint("rectz", &rectz)) rectz=2;
if(!sf_getint("repeat", &repeat)) repeat=2;
if(!sf_getint("scalet", &scalet)) scalet=1;
if(!sf_getint("snap", &snap)) snap=100;
/* interval of the output wavefield */
if(!sf_getint("snapshot", &snapshot)) snapshot=0;
/* print out the wavefield snapshots of this shot */
if(!sf_getint("nds", &nds)) sf_error("Need nds=!");
/* source and receiver positions */
if(!sf_getint("gpz", &gpz)) sf_error("Need gpz=");
if(!sf_getint("spx", &spx)) sf_error("Need spx=");
if(!sf_getint("spz", &spz)) sf_error("Need spz=");
/* tau parameters */
if(!sf_getint("ntau", &ntau)) sf_error("Need ntau=");
if(!sf_getfloat("dtau", &dtau)) sf_error("Need dtau=");
if(!sf_getfloat("tau0", &tau0)) sf_error("Need tau0=");
/* geometry parameters */
if(!sf_getint("rnx", &rnx)) sf_error("Need rnx=");
if(!sf_getint("ndr", &ndr)) ndr=1;
if(!sf_getint("nr0", &nr0)) nr0=0;
/* input/output files */
Fdat=sf_input("--input");
Fimg1=sf_output("--output");
Fimg2=sf_output("Fimg2");
Fsrc=sf_input("Fsrc");
Fvel=sf_input("Fpadvel");
if(wantwf){
Ffwf=sf_output("Ffwf");
Fbwf=sf_output("Fbwf");
}
at=sf_iaxa(Fsrc, 1); nt=sf_n(at); dt=sf_d(at); t0=sf_o(at);
ax=sf_iaxa(Fvel, 2); vnx=sf_n(ax); dx=sf_d(ax); x0=sf_o(ax);
az=sf_iaxa(Fvel, 1); rnz=sf_n(az); dz=sf_d(az); z0=sf_o(az);
if(!sf_histint(Fdat, "n2", &nr)) sf_error("Need n2= in input!");
if(!sf_histint(Fdat, "n3", &ns)) sf_error("Need n3= in input!");
if(!sf_histfloat(Fdat, "d3", &ds)) sf_error("Need d3= in input!");
if(!sf_histfloat(Fdat, "o3", &s0)) sf_error("Need o3= in input!");
wfnt=(nt-1)/scalet+1;
wfdt=dt*scalet;
/* double check the geometry parameters */
if(nds != (int)(ds/dx)) sf_error("Need ds/dx= %d", nds);
//sf_warning("s0=%g, x0+(rnx-1)*dx/2=%g", s0, x0+(rnx-1)*dx/2);
//if(s0 != x0+(rnx-1)*dx/2) sf_error("Wrong origin information!");
if(vnx != nds*(ns-1)+rnx) sf_error("Wrong dimension in x axis!");
/* set up the output files */
atau=sf_iaxa(Fsrc, 1);
sf_setn(atau, ntau);
sf_setd(atau, dtau);
sf_seto(atau, tau0);
sf_setlabel(atau, "Tau");
sf_setunit(atau, "s");
sf_oaxa(Fimg1, az, 1);
sf_oaxa(Fimg1, ax, 2);
sf_oaxa(Fimg1, atau, 3);
sf_oaxa(Fimg2, az, 1);
sf_oaxa(Fimg2, ax, 2);
sf_putint(Fimg2, "n3", 1);
sf_settype(Fimg1, SF_FLOAT);
sf_settype(Fimg2, SF_FLOAT);
if(wantwf){
sf_setn(ax, rnx);
sf_seto(ax, -(rnx-1)*dx/2.0);
sf_oaxa(Ffwf, az, 1);
sf_oaxa(Ffwf, ax, 2);
sf_putint(Ffwf, "n3", (wfnt-1)/snap+1);
sf_putfloat(Ffwf, "d3", snap*wfdt);
sf_putfloat(Ffwf, "o3", t0);
sf_putstring(Ffwf, "label3", "Time");
sf_putstring(Ffwf, "unit3", "s");
sf_settype(Ffwf, SF_FLOAT);
sf_oaxa(Fbwf, az, 1);
sf_oaxa(Fbwf, ax, 2);
sf_putint(Fbwf, "n3", (wfnt-1)/snap+1);
sf_putfloat(Fbwf, "d3", -snap*wfdt);
sf_putfloat(Fbwf, "o3", (wfnt-1)*wfdt);
sf_putstring(Fbwf, "label3", "Time");
sf_putstring(Fbwf, "unit3", "s");
sf_settype(Fbwf, SF_FLOAT);
}
nx=rnx+2*nb; nz=rnz+2*nb;
nzx=nx*nz; rnzx=rnz*rnx;
nk=cfft2_init(pad1, nz, nx, &fnz, &fnx);
fnzx=fnz*fnx;
if(ns%numprocs==0) nspad=ns;
else nspad=(ns/numprocs+1)*numprocs;
/* print axies parameters for double check */
sf_warning("cpuid=%d, numprocs=%d, nspad=%d", cpuid, numprocs, nspad);
sf_warning("nt=%d, dt=%g, scalet=%d, wfnt=%d, wfdt=%g",nt, dt, scalet, wfnt, wfdt);
sf_warning("vnx=%d, nx=%d, dx=%g, nb=%d, rnx=%d", vnx, nx, dx, nb, rnx);
sf_warning("nr=%d, ndr=%d, nr0=%g", nr, ndr, nr0);
sf_warning("nz=%d, rnz=%d, dz=%g, z0=%g", nz, rnz, dz, z0);
sf_warning("spx=%d, spz=%d, gpz=%d", spx, spz, gpz);
sf_warning("ns=%d, ds=%g, s0=%g", ns, ds, s0);
sf_warning("ntau=%d, dtau=%g, tau0=%g", ntau, dtau, tau0);
sf_warning("nzx=%d, fnzx=%d, nk=%d", nzx, fnzx, nk);
/* allocate storage and read data */
ww=sf_complexalloc(nt);
sf_complexread(ww, nt, Fsrc);
sf_fileclose(Fsrc);
gpz=gpz+nb;
spz=spz+nb;
spx=spx+nb;
nr0=nr0+nb;
trunc=srctrunc/dt+0.5;
dd=sf_complexalloc2(nt, nr);
if(cpuid==0) dd3=sf_complexalloc3(nt, nr, numprocs);
rr=sf_floatalloc(nzx);
reflgen(nz, nx, spz, spx, rectz, rectx, repeat, rr);
fwf=sf_floatalloc3(rnz, rnx, wfnt);
bwf=sf_floatalloc3(rnz, rnx, wfnt);
img1=sf_floatalloc3(rnz, vnx, ntau);
img2=sf_floatalloc2(rnz, vnx);
mig1=sf_floatalloc3(rnz, rnx, ntau);
mig2=sf_floatalloc2(rnz, rnx);
ccr=sf_floatalloc2(rnz, rnx);
sill=sf_floatalloc2(rnz, rnx);
curr=sf_complexalloc(fnzx);
cwave=sf_complexalloc(nk);
cwavem=sf_complexalloc(nk);
icfft2_allocate(cwavem);
if (taper!=0) {
dkz = 1./(fnz*dz); kz0 = -0.5/dz;
dkx = 1./(fnx*dx); kx0 = -0.5/dx;
nkz = fnz;
sf_warning("dkz=%f,dkx=%f,kz0=%f,kx0=%f",dkz,dkx,kz0,kx0);
sf_warning("nk=%d,nkz=%d,nkx=%d",nk,nkz,fnx);
kx_trs = thresh*fabs(0.5/dx);
kz_trs = thresh*fabs(0.5/dz);
sf_warning("Applying kz tapering below %f",kz_trs);
sf_warning("Applying kx tapering below %f",kx_trs);
ktp = sf_floatalloc(nk);
/* constructing the tapering op */
for (ix=0; ix < fnx; ix++) {
kx = kx0+ix*dkx;
for (iz=0; iz < nkz; iz++) {
kz = kz0+iz*dkz;
ktmp = 1.;
if (fabs(kx) > kx_trs)
ktmp *= powf((2*kx_trs - fabs(kx))/(kx_trs),2);
if (fabs(kz) > kz_trs)
ktmp *= powf((2*kz_trs - fabs(kz))/(kz_trs),2);
ktp[iz+ix*nkz] = ktmp;
}
}
}
/* initialize image tables that would be used for summing images */
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz, itau)
#endif
for(ix=0; ix<vnx; ix++){
for(iz=0; iz<rnz; iz++){
img2[ix][iz]=0.;
for(itau=0; itau<ntau; itau++){
img1[itau][ix][iz]=0.;
}
}
}
path1=sf_getstring("path1");
path2=sf_getstring("path2");
if(path1==NULL) path1="./mat/left";
if(path2==NULL) path2="./mat/right";
/* shot loop */
for (iturn=0; iturn*numprocs<nspad; iturn++){
is=iturn*numprocs+cpuid;
/* read data */
if(cpuid==0){
sf_seek(Fdat, ((off_t) is)*((off_t) nr)*((off_t) nt)*sizeof(float complex), SEEK_SET);
if((iturn+1)*numprocs<=ns){
sf_complexread(dd3[0][0], nr*nt*numprocs, Fdat);
}else{
sf_complexread(dd3[0][0], nr*nt*(ns-iturn*numprocs), Fdat);
for(is=ns; is<nspad; is++)
for(ix=0; ix<nr; ix++)
for(it=0; it<nt; it++)
dd3[is-iturn*numprocs][ix][it]=sf_cmplx(0.,0.);
is=iturn*numprocs;
}
sendbufc=dd3[0][0];
recvbufc=dd[0];
}else{
sendbufc=NULL;
recvbufc=dd[0];
}
MPI_Scatter(sendbufc, nt*nr, MPI_COMPLEX, recvbufc, nt*nr, MPI_COMPLEX, 0, comm);
if(is<ns){ /* effective shot loop */
/* construct the names of left and right matrices */
left=sf_charalloc(strlen(path1));
right=sf_charalloc(strlen(path2));
strcpy(left, path1);
strcpy(right, path2);
sprintf(number, "%d", is+1);
strcat(left, number);
strcat(right, number);
Fleft=sf_input(left);
Fright=sf_input(right);
if(!sf_histint(Fleft, "n1", &n) || n != nzx) sf_error("Need n1=%d in Fleft", nzx);
if(!sf_histint(Fleft, "n2", &m)) sf_error("No n2 in Fleft");
if(!sf_histint(Fright, "n1", &n) || n != m) sf_error("Need n1=%d in Fright", m);
if(!sf_histint(Fright, "n2", &n) || n != nk) sf_error("Need n2=%d in Fright", nk);
/* allocate storage for each shot migration */
lt=sf_complexalloc2(nzx, m);
rt=sf_complexalloc2(m, nk);
sf_complexread(lt[0], nzx*m, Fleft);
sf_complexread(rt[0], m*nk, Fright);
sf_fileclose(Fleft);
sf_fileclose(Fright);
/* initialize curr and imaging variables */
#ifdef _OPENMP
#pragma omp parallel for private(iz)
#endif
for(iz=0; iz<fnzx; iz++){
curr[iz]=sf_cmplx(0.,0.);
}
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz, itau)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
mig2[ix][iz]=0.;
ccr[ix][iz]=0.;
sill[ix][iz]=0.;
for(itau=0; itau<ntau; itau++){
mig1[itau][ix][iz]=0.;
}
}
}
/* wave */
wave=sf_complexalloc2(fnzx, m);
/* snapshot */
if(wantwf && is==snapshot) wantwf=true;
else wantwf=false;
/* forward propagation */
wfit=0;
for(it=0; it<nt; it++){
if(verb) sf_warning("Forward propagation it=%d/%d",it+1, nt);
cfft2(curr, cwave);
for(im=0; im<m; im++){
#ifdef _OPENMP
#pragma omp parallel for private(ik)
#endif
for(ik=0; ik<nk; ik++){
#ifdef SF_HAS_COMPLEX_H
cwavem[ik]=cwave[ik]*rt[ik][im];
#else
cwavem[ik]=sf_cmul(cwave[ik],rt[ik][im]);
#endif
}
icfft2(wave[im],cwavem);
}
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz, i, j, im, c) shared(curr, it)
#endif
for(ix=0; ix<nx; ix++){
for(iz=0; iz<nz; iz++){
i=iz+ix*nz;
j=iz+ix*fnz;
if(it<trunc){
#ifdef SF_HAS_COMPLEX_H
c=ww[it]*rr[i];
#else
c=sf_crmul(ww[it],rr[i]);
#endif
}else{
c=sf_cmplx(0.,0.);
}
// c += curr[j];
for(im=0; im<m; im++){
#ifdef SF_HAS_COMPLEX_H
c += lt[im][i]*wave[im][j];
#else
c += sf_cmul(lt[im][i], wave[im][j]);
#endif
}
curr[j]=c;
}
}
if (taper!=0) {
if (it%taper == 0) {
cfft2(curr,cwave);
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*ktp[ik];
#else
cwavem[ik] = sf_crmul(cwave[ik],ktp[ik]);
#endif
}
icfft2(curr,cwavem);
}
}
if(it%scalet==0){
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
fwf[wfit][ix][iz]=crealf(curr[(ix+nb)*fnz+(iz+nb)]);
}
}
wfit++;
}
} //end of it
/* check wfnt */
if(wfit != wfnt) sf_error("At this point, wfit should be equal to wfnt");
/* backward propagation starts from here... */
#ifdef _OPENMP
#pragma omp parallel for private(iz)
#endif
for(iz=0; iz<fnzx; iz++){
curr[iz]=sf_cmplx(0.,0.);
}
wfit=wfnt-1;
for(it=nt-1; it>=0; it--){
if(verb) sf_warning("Backward propagation it=%d/%d",it+1, nt);
#ifdef _OPENMP
#pragma omp parallel for private(ix)
#endif
for(ix=0; ix<nr; ix++){
curr[(nr0+ix*ndr)*fnz+gpz]+=dd[ix][it];
}
cfft2(curr, cwave);
for(im=0; im<m; im++){
#ifdef _OPENMP
#pragma omp parallel for private(ik)
#endif
for(ik=0; ik<nk; ik++){
#ifdef SF_HAS_COMPLEX_H
cwavem[ik]=cwave[ik]*conjf(rt[ik][im]);
#else
cwavem[ik]=sf_cmul(cwave[ik],conjf(rt[ik][im]));
#endif
}
icfft2(wave[im],cwavem);
}
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz, i, j, im, c) shared(curr, it)
#endif
for(ix=0; ix<nx; ix++){
for(iz=0; iz<nz; iz++){
i=iz+ix*nz;
j=iz+ix*fnz;
// c=curr[j];
c=sf_cmplx(0.,0.);
for(im=0; im<m; im++){
#ifdef SF_HAS_COMPLEX_H
c += conjf(lt[im][i])*wave[im][j];
#else
c += sf_cmul(conjf(lt[im][i]), wave[im][j]);
#endif
}
curr[j]=c;
}
}
if (taper!=0) {
if (it%taper == 0) {
cfft2(curr,cwave);
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*ktp[ik];
#else
cwavem[ik] = sf_crmul(cwave[ik],ktp[ik]);
#endif
}
icfft2(curr,cwavem);
}
}
if(it%scalet==0){
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
bwf[wfit][ix][iz]=crealf(curr[(ix+nb)*fnz+(iz+nb)]);
ccr[ix][iz] += fwf[wfit][ix][iz]*bwf[wfit][ix][iz];
sill[ix][iz] += fwf[wfit][ix][iz]*fwf[wfit][ix][iz];
}
}
wfit--;
}
} //end of it
if(wfit != -1) sf_error("Check program! The final wfit should be -1!");
/* free storage */
free(*rt); free(rt);
free(*lt); free(lt);
free(*wave); free(wave);
free(left); free(right);
/* normalized image */
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for (ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
mig2[ix][iz]=ccr[ix][iz]/(sill[ix][iz]+SF_EPS);
// sill[ix][iz]=0.;
}
}
/* time-shift imaging condition */
for(itau=0; itau<ntau; itau++){
//sf_warning("itau/ntau=%d/%d", itau+1, ntau);
tau=itau*dtau+tau0;
htau=tau/wfdt;
for(it=abs(htau); it<wfnt-abs(htau); it++){
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
mig1[itau][ix][iz]+=fwf[it+htau][ix][iz]*bwf[it-htau][ix][iz];
// sill[ix][iz]+=fwf[it+htau][ix][iz]*fwf[it+htau][ix][iz];
} // end of iz
} // end of ix
} // end of it
//#ifdef _OPENMP
//#pragma omp parallel for private(ix, iz)
//#endif
/* source illumination */
// for(ix=0; ix<rnx; ix++){
// for(iz=0; iz<rnz; iz++){
// mig1[itau][ix][iz] = mig1[itau][ix][iz]/(sill[ix][iz]+SF_EPS);
// }
// }
} //end of itau
/* output wavefield snapshot */
if(wantwf){
for(it=0; it<wfnt; it++){
if(it%snap==0){
sf_floatwrite(fwf[it][0], rnzx, Ffwf);
sf_floatwrite(bwf[wfnt-1-it][0], rnzx, Fbwf);
}
}
sf_fileclose(Ffwf);
sf_fileclose(Fbwf);
}
/* add all the shot images that are on the same node */
#ifdef _OPENMP
#pragma omp parallel for private(itau, ix, iz)
#endif
for(itau=0; itau<ntau; itau++){
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
img1[itau][ix+is*nds][iz] += mig1[itau][ix][iz];
}
}
}
#ifdef _OPENMP
#pragma omp parallel for private(ix, iz)
#endif
for(ix=0; ix<rnx; ix++){
for(iz=0; iz<rnz; iz++){
img2[ix+is*nds][iz] += mig2[ix][iz];
}
}
} // end of is<ns
} // end of iturn
////////////////end of ishot
MPI_Barrier(comm);
cfft2_finalize();
sf_fileclose(Fdat);
free(ww); free(rr);
free(*dd); free(dd);
if(cpuid==0) {free(**dd3); free(*dd3); free(dd3);}
free(cwave); free(cwavem); free(curr);
free(*ccr); free(ccr);
free(*sill); free(sill);
free(**fwf); free(*fwf); free(fwf);
free(**bwf); free(*bwf); free(bwf);
free(**mig1); free(*mig1); free(mig1);
free(*mig2); free(mig2);
/* sum image */
if(cpuid==0){
sendbuf=(float *)MPI_IN_PLACE;
recvbuf=img1[0][0];
}else{
sendbuf=img1[0][0];
recvbuf=NULL;
}
MPI_Reduce(sendbuf, recvbuf, ntau*vnx*rnz, MPI_FLOAT, MPI_SUM, 0, comm);
if(cpuid==0){
sendbuf=MPI_IN_PLACE;
recvbuf=img2[0];
}else{
sendbuf=img2[0];
recvbuf=NULL;
}
MPI_Reduce(sendbuf, recvbuf, vnx*rnz, MPI_FLOAT, MPI_SUM, 0, comm);
/* output image */
if(cpuid==0){
sf_floatwrite(img1[0][0], ntau*vnx*rnz, Fimg1);
sf_floatwrite(img2[0], vnx*rnz, Fimg2);
}
MPI_Barrier(comm);
sf_fileclose(Fimg1);
sf_fileclose(Fimg2);
free(**img1); free(*img1); free(img1);
free(*img2); free(img2);
gettimeofday(&tim, NULL);
tend=tim.tv_sec+(tim.tv_usec/1000000.0);
sf_warning(">> The computing time is %.3lf minutes <<", (tend-tstart)/60.);
MPI_Finalize();
exit(0);
}
int main(int argc, char* argv[])
{
bool verb, save, load;
int npml, pad1, pad2, n1, n2;
int ih, nh, is, ns, iw, nw, i, j;
SuiteSparse_long n, nz, *Ti, *Tj;
float d1, d2, **vel, ****image, ****timage, dw, ow;
double omega, *Tx, *Tz;
SuiteSparse_long *Ap, *Ai, *Map;
double *Ax, *Az, **Xx, **Xz, **Bx, **Bz;
void *Symbolic, **Numeric;
double Control[UMFPACK_CONTROL];
sf_complex ***srce, ***recv;
char *datapath, *insert, *append;
size_t srclen, inslen;
sf_file in, out, source, data, us, ur, timg;
int uts, its, mts;
sf_timer timer;
char *order;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
if (verb)
timer = sf_timer_init();
else
timer = NULL;
if (!sf_getbool("save",&save)) save=false;
/* save LU */
if (!sf_getbool("load",&load)) load=false;
/* load LU */
if (save || load) {
datapath = sf_histstring(in,"in");
srclen = strlen(datapath);
insert = sf_charalloc(6);
} else {
datapath = NULL;
srclen = 0;
insert = NULL;
append = NULL;
}
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;
if (verb) sf_warning("Using %d out of %d threads.",uts,mts);
if (!sf_getint("nh",&nh)) nh=0;
/* horizontal space-lag */
if (!sf_getint("npml",&npml)) npml=10;
/* PML width */
if (NULL == (order = sf_getstring("order"))) order="j";
/* discretization scheme (default optimal 9-point) */
fdprep_order(order);
/* read model */
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input.");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input.");
if (!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input.");
if (!sf_histfloat(in,"d2",&d2)) sf_error("No d2= in input.");
vel = sf_floatalloc2(n1,n2);
sf_floatread(vel[0],n1*n2,in);
/* read source */
if (NULL == sf_getstring("source"))
sf_error("Need source=");
source = sf_input("source");
if (!sf_histint(source,"n3",&ns)) sf_error("No ns=.");
if (!sf_histint(source,"n4",&nw)) sf_error("No nw=.");
if (!sf_histfloat(source,"d4",&dw)) sf_error("No dw=.");
if (!sf_histfloat(source,"o4",&ow)) sf_error("No ow=.");
srce = sf_complexalloc3(n1,n2,ns);
/* read receiver */
if (NULL == sf_getstring("data"))
sf_error("Need data=");
data = sf_input("data");
recv = sf_complexalloc3(n1,n2,ns);
/* write output header */
sf_putint(out,"n3",2*nh+1);
sf_putfloat(out,"d3",d2);
sf_putfloat(out,"o3",(float) -nh*d2);
/* output source wavefield */
if (NULL != sf_getstring("us")) {
us = sf_output("us");
sf_settype(us,SF_COMPLEX);
sf_putint(us,"n3",ns);
sf_putstring(us,"label3","Shot");
sf_putstring(us,"unit3","");
sf_putint(us,"n4",nw);
sf_putfloat(us,"d4",dw);
sf_putfloat(us,"o4",ow);
sf_putstring(us,"label4","Frequency");
sf_putstring(us,"unit4","Hz");
} else {
us = NULL;
}
/* output receiver wavefield */
if (NULL != sf_getstring("ur")) {
ur = sf_output("ur");
sf_settype(ur,SF_COMPLEX);
sf_putint(ur,"n3",ns);
sf_putstring(ur,"label3","Shot");
sf_putstring(ur,"unit3","");
sf_putint(ur,"n4",nw);
sf_putfloat(ur,"d4",dw);
sf_putfloat(ur,"o4",ow);
sf_putstring(ur,"label4","Frequency");
sf_putstring(ur,"unit4","Hz");
} else {
ur = NULL;
}
/* output time-shift image derivative */
if (NULL != sf_getstring("timg")) {
timg = sf_output("timg");
sf_putint(timg,"n3",2*nh+1);
sf_putfloat(timg,"d3",d2);
sf_putfloat(timg,"o3",(float) -nh*d2);
timage = (float****) sf_alloc(uts,sizeof(float***));
for (its=0; its < uts; its++) {
timage[its] = sf_floatalloc3(n1,n2,2*nh+1);
}
} else {
timg = NULL;
timage = NULL;
}
/* allocate temporary memory */
if (load) {
Ti = NULL; Tj = NULL; Tx = NULL; Tz = NULL;
Ap = NULL; Ai = NULL; Map = NULL; Ax = NULL; Az = NULL;
}
Bx = (double**) sf_alloc(uts,sizeof(double*));
Bz = (double**) sf_alloc(uts,sizeof(double*));
Xx = (double**) sf_alloc(uts,sizeof(double*));
Xz = (double**) sf_alloc(uts,sizeof(double*));
image = (float****) sf_alloc(uts,sizeof(float***));
for (its=0; its < uts; its++) {
image[its] = sf_floatalloc3(n1,n2,2*nh+1);
}
Numeric = (void**) sf_alloc(uts,sizeof(void*));
/* LU control */
umfpack_zl_defaults (Control);
Control [UMFPACK_IRSTEP] = 0;
/* loop over frequency */
for (iw=0; iw < nw; iw++) {
omega = (double) 2.*SF_PI*(ow+iw*dw);
/* PML padding */
pad1 = n1+2*npml;
pad2 = n2+2*npml;
n = fdprep_n (pad1,pad2);
nz = fdprep_nz(pad1,pad2);
if (!load) {
Ti = (SuiteSparse_long*) sf_alloc(nz,sizeof(SuiteSparse_long));
Tj = (SuiteSparse_long*) sf_alloc(nz,sizeof(SuiteSparse_long));
Tx = (double*) sf_alloc(nz,sizeof(double));
Tz = (double*) sf_alloc(nz,sizeof(double));
Ap = (SuiteSparse_long*) sf_alloc(n+1,sizeof(SuiteSparse_long));
Ai = (SuiteSparse_long*) sf_alloc(nz,sizeof(SuiteSparse_long));
Map = (SuiteSparse_long*) sf_alloc(nz,sizeof(SuiteSparse_long));
Ax = (double*) sf_alloc(nz,sizeof(double));
Az = (double*) sf_alloc(nz,sizeof(double));
}
for (its=0; its < uts; its++) {
Bx[its] = (double*) sf_alloc(n,sizeof(double));
Bz[its] = (double*) sf_alloc(n,sizeof(double));
Xx[its] = (double*) sf_alloc(n,sizeof(double));
Xz[its] = (double*) sf_alloc(n,sizeof(double));
}
if (verb) {
sf_warning("Frequency %d of %d.",iw+1,nw);
sf_timer_start(timer);
}
/* LU file (append _lu* after velocity file) */
if (save || load) {
sprintf(insert,"_lu%d",iw);
inslen = strlen(insert);
append = malloc(srclen+inslen+1);
memcpy(append,datapath,srclen-5);
memcpy(append+srclen-5,insert,inslen);
memcpy(append+srclen-5+inslen,datapath+srclen-5,5+1);
}
if (!load) {
/* assemble matrix */
fdprep(omega,
n1, n2, d1, d2, vel,
npml, pad1, pad2,
Ti, Tj, Tx, Tz);
(void) umfpack_zl_triplet_to_col (n, n, nz,
Ti, Tj, Tx, Tz,
Ap, Ai, Ax, Az, Map);
/* LU */
(void) umfpack_zl_symbolic (n, n,
Ap, Ai, Ax, Az,
&Symbolic, Control, NULL);
(void) umfpack_zl_numeric (Ap, Ai, Ax, Az,
Symbolic, &Numeric[0],
Control, NULL);
/* save Numeric */
#ifdef _OPENMP
(void) umfpack_zl_save_numeric (Numeric[0], append);
for (its=1; its < uts; its++) {
(void) umfpack_zl_load_numeric (&Numeric[its], append);
}
if (!save) {
(void) remove (append);
(void) remove ("numeric.umf");
}
#else
if (save) (void) umfpack_zl_save_numeric (Numeric[0], append);
#endif
} else {
/* load Numeric */
for (its=0; its < uts; its++) {
(void) umfpack_zl_load_numeric (&Numeric[its], append);
}
}
if (save || load) free(append);
/* read source and data */
sf_complexread(srce[0][0],n1*n2*ns,source);
sf_complexread(recv[0][0],n1*n2*ns,data);
/* loop over shots */
#ifdef _OPENMP
#pragma omp parallel for num_threads(uts) private(its,ih,j,i)
#endif
for (is=0; is < ns; is++) {
#ifdef _OPENMP
its = omp_get_thread_num();
#else
its = 0;
#endif
/* source wavefield */
fdpad(npml,pad1,pad2, srce[is],Bx[its],Bz[its]);
(void) umfpack_zl_solve (UMFPACK_A,
NULL, NULL, NULL, NULL,
Xx[its], Xz[its], Bx[its], Bz[its],
Numeric[its], Control, NULL);
fdcut(npml,pad1,pad2, srce[is],Xx[its],Xz[its]);
/* receiver wavefield */
fdpad(npml,pad1,pad2, recv[is],Bx[its],Bz[its]);
(void) umfpack_zl_solve (UMFPACK_At,
NULL, NULL, NULL, NULL,
Xx[its], Xz[its], Bx[its], Bz[its],
Numeric[its], Control, NULL);
fdcut(npml,pad1,pad2, recv[is],Xx[its],Xz[its]);
/* imaging condition */
for (ih=-nh; ih < nh+1; ih++) {
for (j=0; j < n2; j++) {
for (i=0; i < n1; i++) {
if (j-abs(ih) >= 0 && j+abs(ih) < n2) {
image[its][ih+nh][j][i] += crealf(conjf(srce[is][j-ih][i])*recv[is][j+ih][i]);
if (timg != NULL) timage[its][ih+nh][j][i]
+= crealf(2.*I*omega*conjf(srce[is][j-ih][i])*recv[is][j+ih][i]);
}
}
}
}
}
if (verb) {
sf_timer_stop (timer);
sf_warning("Finished in %g seconds.",sf_timer_get_diff_time(timer)/1.e3);
}
if (!load) (void) umfpack_zl_free_symbolic (&Symbolic);
for (its=0; its < uts; its++) {
(void) umfpack_zl_free_numeric (&Numeric[its]);
}
if (!load) {
free(Ti); free(Tj); free(Tx); free(Tz);
free(Ap); free(Ai); free(Map);
free(Ax); free(Az);
}
for (its=0; its < uts; its++) {
free(Bx[its]); free(Bz[its]); free(Xx[its]); free(Xz[its]);
}
if (us != NULL) sf_complexwrite(srce[0][0],n1*n2*ns,us);
if (ur != NULL) sf_complexwrite(recv[0][0],n1*n2*ns,ur);
}
#ifdef _OPENMP
#pragma omp parallel for num_threads(uts) private(j,i,its)
for (ih=-nh; ih < nh+1; ih++) {
for (j=0; j < n2; j++) {
for (i=0; i < n1; i++) {
for (its=1; its < uts; its++) {
image[0][ih+nh][j][i] += image[its][ih+nh][j][i];
if (timg != NULL) timage[0][ih+nh][j][i]
+= timage[its][ih+nh][j][i];
}
}
}
}
#endif
sf_floatwrite(image[0][0][0],n1*n2*(2*nh+1),out);
if (timg != NULL) sf_floatwrite(timage[0][0][0],n1*n2*(2*nh+1),timg);
exit(0);
}
int main(int argc, char* argv[])
{
int nz,nx,na;
float oz,ox,oa;
float dz,dx,da;
int iq; /* escape variables switch */
int ix; /* grid points in x */
int iz; /* grid points in z */
int ia; /* grid points in a */
int iter, niter; /* number of iterations */
int ix0, ix1, ixs;
int iz0, iz1, izs;
int ia0, ia1, ias;
float a; /* angle */
float ***t; /* escape variable */
float **v,**vx,**vz; /* slowness, gradients */
float vel, velx, velz;
float cs,sn;
float new_val;
float cvt,tol;
sf_file in,out,slow,slowz,slowx;
float sl_vti, sl_vti_inv;
char is_P_SH_SV, *whatV;
float Hp, Hq, p_gradH, dl_dsigma, da_dsigma;
float
vti_eps = 0.20, /*0.2, */
vti_gamma=0.20, /*0.2, */
vti_delta=-0.450; /*-0.45;*/
struct VTIStruct VTI;
/* bool swap_dir_x=1, swap_dir_z=1; */
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_getint("iq",&iq)) sf_error("Need iq=");
/* switch for escape variable 0=x, 1=a, 2=t, 3=z, 4=l */
whatV = sf_getstring ("vti");
/* what to compute (p=qP, v=qSV, h=SH) */
if (NULL == whatV) {
whatV = "p";
} else {
if (whatV[0] != 'p' && whatV[0] != 'v' && whatV[0] != 'h')
sf_error ("Need vti=p|v|h");
}
is_P_SH_SV = whatV[0];
/* read input file parameters */
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float");
if (!sf_histint(in,"n1",&nz)) sf_error("No n1=");
if (!sf_histfloat(in,"d1",&dz)) sf_error("No d1=");
if (!sf_histfloat(in,"o1",&oz)) sf_error("No o1=");
if (!sf_histint(in,"n2",&nx)) sf_error("No n2=");
if (!sf_histfloat(in,"d2",&dx)) sf_error("No d2=");
if (!sf_histfloat(in,"o2",&ox)) sf_error("No o2=");
if (!sf_histint(in,"n3",&na)) sf_error("No n3=");
if (!sf_histfloat(in,"d3",&da)) sf_error("No d3=");
if (!sf_histfloat(in,"o3",&oa)) sf_error("No o3=");
/* angle in degrees */
if (!sf_getint("niter",&niter)) niter=50;
/* number of Gauss-Seidel iterations */
if (!sf_getfloat("tol",&tol)) tol=0.000002*nx*nz;
/* accuracy tolerance */
if (!sf_getfloat("vti_eps",&vti_eps)) vti_eps=0.0;
if (!sf_getfloat("vti_gamma",&vti_gamma)) vti_gamma=0.0;
if (!sf_getfloat("vti_delta",&vti_delta)) vti_delta=0.0;
/* VTI constants Thomsen */
/* memory allocations */
/* Solution vector */
t = sf_floatalloc3(nz,nx,na);
/* read input escape variable - initial guess */
sf_floatread(t[0][0],nz*nx*na,in);
/*
for (int ix=0; ix < nx; ix++)
for (int iz=0; iz < nz; iz++)
for (int ia=0; ia < na; ia++)
t[ia][ix][iz] = 1e10f;
*/
/* read auxiliary slowness file */
slow = sf_input("vel");
v = sf_floatalloc2(nz,nx);
sf_floatread(v[0],nz*nx,slow);
/* read auxiliary slowness z-gradient file */
slowz = sf_input("velz");
vz = sf_floatalloc2(nz,nx);
sf_floatread(vz[0],nz*nx,slowz);
/* read auxiliary slowness x-gradient file */
slowx = sf_input("velx");
vx = sf_floatalloc2(nz,nx);
sf_floatread(vx[0],nz*nx,slowx);
/* convert to radians */
oa *= SF_PI/180.;
da *= SF_PI/180.;
ia0=0; ia1=na; ias=1;
gsray_init(nz,nx,na,
oz,ox,oa,
dz,dx,da);
/* Greenriver shale example
alfa=3.29 beta=1.77 eps=0.195 gamma=0.18 delat=-0.45 */
vti_init_greenriver_c(&VTI);
vti_c2thomsen(&VTI);
for (iter=0; iter < niter; iter++) {
cvt = 0.0; /* X_next - X_prev */
int num_fails = 0;
/* Gauss-Seidel iteration on angle */
for (ia = ia0; ia != ia1; ia += ias) {
a = oa + ia*da;
cs = cosf(a);
sn = sinf(a);
/* assert (fabs(sn) > 1e-6 && fabs(cs) > 1e-6);
Hq = -sn;
Hp = -cs; */
vti_gauss_2_c(&VTI, v[0][0], vx[0][0], vz[0][0], vti_eps, vti_gamma, vti_delta);
vti_c11_2_c1(&VTI);
sl_vti = vti_slowness_c(&VTI, cs*cs, sn*sn, is_P_SH_SV, &sl_vti_inv);
Svti(&VTI, sl_vti, sl_vti_inv, is_P_SH_SV, cs, sn, &Hp, &Hq, (float*)0, (float*)0, (float*)0);//&da_dsigma);
if (1e-6 < Hq) {
ix0=nx-2; ix1=-1; ixs=-1;
for (iz = 0; iz < nz; iz++)
boundary_mat(t,iz,nx-1,ia,iq);
} else {
ix0=1; ix1=nx; ixs=1;
for (iz = 0; iz < nz; iz++)
boundary_mat(t,iz,0,ia,iq);
}
if (1e-6 < Hp) {
iz0=nz-2; iz1=-1; izs=-1;
for (ix = 0; ix < nx; ix++)
boundary_mat(t,nz-1,ix,ia,iq);
} else {
iz0=1; iz1=nz; izs=1;
for (ix = 0; ix < nx; ix++)
boundary_mat(t,0,ix,ia,iq);
}
/* loop over grid Z.X */
for (ix = ix0; ix != ix1; ix += ixs) {
for (iz = iz0; iz != iz1; iz += izs) {
vel = v[ix][iz];
velx = vx[ix][iz];
velz = vz[ix][iz];
vti_gauss_2_c(&VTI, vel, velx, velz, vti_eps, vti_gamma, vti_delta);
vti_c11_2_c1(&VTI);
sl_vti = vti_slowness_c(&VTI, cs*cs, sn*sn, is_P_SH_SV, &sl_vti_inv);
Svti(&VTI, sl_vti, sl_vti_inv, is_P_SH_SV, cs, sn, &Hp, &Hq, &p_gradH, &dl_dsigma, &da_dsigma);
vti_c2thomsen(&VTI);
assert(fabs(VTI.eps - vti_eps) < 1e-6);
assert(fabs(VTI.gamma - vti_gamma) < 1e-6);
assert(fabs(VTI.delta - vti_delta) < 1e-6);
/* Gauss-Seidel update
new_val = gs_update(t,iz,ix,ia,ss,ssz,ssx,cs,sn,iq); */
new_val = gs_update(t,-Hp, -Hq, -da_dsigma, iz,ix,ia, p_gradH, dl_dsigma, iq);
/* new_val = fmin(new_val, t[ia][ix][iz]); */
cvt += fabsf(t[ia][ix][iz]-new_val);
/* t[ia][ix][iz] = fmin(new_val, t[ia][ix][iz]); */
t[ia][ix][iz] = new_val;
/* if (t[ia][ix][iz] > 1000) num_fails++; */
} /* ix */
} /* iz */
} /* ia */
sf_warning("Iter = %d, Norm L1 = %g num fails = %d sweep=%g %g",iter,cvt/(nx*nz*na), num_fails,Hp,Hq);
/* tol is tolerance for convergence */
if (cvt < tol) break;
/* alternate updating direction on angle grid*/
if (0 == ia0) {
ia0 = na-1; ia1 = -1; ias = -1;
} else {
ia0 = 0; ia1 = na; ias = 1;
}
} /* end G-S iterations */
/* output */
sf_floatwrite(t[0][0],nz*nx*na,out);
exit(0);
}
int main(int argc, char* argv[])
{
bool verb;
int i, nz, iz, nh, ih, ncdp, icdp, np, ip, jtau, *itau, *mute, *npicks;
float dz, dh, dcdp, cut, s, z, h;
float *tau, **ztau, *semb;
sf_file in, pick, npick, semblance;
FILE *fp;
sf_init(argc, argv);
in = sf_input("in");
pick = sf_input("pick");
npick = sf_input("npick");
semblance = sf_input("semblance");
fp=fopen("sogpicks.txt","w");
if (!sf_histint(in,"n1",&nz)) sf_error("No n1= in input");
if (!sf_histfloat(in,"d1",&dz)) sf_error("No d1= in input");
if (!sf_histint(in,"n2",&nh)) sf_error("No n2= in input");
if (!sf_histfloat(in,"d2",&dh)) sf_error("No d2= in input");
ncdp = sf_leftsize(in,2);
if (!sf_histfloat(in,"d3",&dcdp)) sf_error("No d3= in input");
if (!sf_histint(pick,"n1",&np)) sf_error("No n1= in pick");
if (!sf_getbool("verb",&verb)) verb=true;
/* if y, print icdp/ncdp during operation */
if (!sf_getfloat("cut",&cut)) cut=0.;
/* muting value in boundary */
itau = sf_intalloc(np);
tau = sf_floatalloc(np);
mute = sf_intalloc(nz);
ztau = sf_floatalloc2(nz, nh);
semb = sf_floatalloc(nz);
npicks = sf_intalloc(ncdp);
sf_intread(npicks, ncdp, npick);
for (icdp=0; icdp < ncdp; icdp++) {
if(verb) sf_warning("icdp/ncdp=%d/%d;",icdp+1, ncdp);
/* read data */
sf_floatread(ztau[0], nz*nh, in);
sf_floatread(tau, np, pick);
sf_floatread(semb, nz, semblance);
for (ip=0; ip<np; ip++){
itau[ip] = tau[ip]/dz+0.5;
}
/* muting boundary */
for (iz=0; iz<nz; iz++){
if(ztau[0][iz]>=cut) break;
}
for (i=0; i<iz; i++) mute[i]=dz*(nh-1)*(iz-i)/cut+0.5;
for (i=iz; i<nz; i++) mute[i]=0;
fprintf(fp, "%4d %11.5f %2d\n", icdp+1, icdp*dcdp, npicks[icdp]);
for (ip=0; ip<npicks[icdp]; ip++){
jtau=itau[npicks[icdp]-1-ip];
fprintf(fp, "%2d %11.5f %3d\n", ip+1, jtau*dz, nh-mute[jtau]);
s=semb[jtau];
for (ih=nh-1; ih>=mute[jtau]; ih--){
h=dh*(nh-1-ih);
z=ztau[ih][jtau];
fprintf(fp, "%11.5f %11.5f %6.5f\n", h, z, s);
} // end of ih
} // end of ip
} // end of icdp
fclose(fp);
exit(0);
}
int main(int argc, char *argv[])
{
int nk, nh, iw, nw, i4, n4, ik;
float k0, dk, h0, dh, w0, dw, w, k, eps;
bool inv, verb, adj, dwt;
char *type;
sf_complex *pp, *qq;
sf_file in, out;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (SF_COMPLEX != sf_gettype(in)) sf_error("Need complex input");
if (!sf_histint(in,"n1",&nh)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&nk)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&nw)) sf_error("No n3= in input");
if (!sf_histfloat(in,"d1",&dh)) sf_error("No d1= in input");
if (!sf_histfloat(in,"d2",&dk)) sf_error("No d2= in input");
if (!sf_histfloat(in,"d3",&dw)) sf_error("No d3= in input");
if (!sf_histfloat(in,"o1",&h0)) sf_error("No o1= in input");
if (!sf_histfloat(in,"o2",&k0)) sf_error("No o2= in input");
if (!sf_histfloat(in,"o3",&w0)) sf_error("No o3= in input");
n4 = sf_leftsize(in,3);
if (!sf_getbool("inv",&inv)) inv=false;
/* if y, do inverse transform */
if (!sf_getbool("adj",&adj)) adj=false;
/* if y, do adjoint transform */
if (!sf_getbool("dwt",&dwt)) dwt=false;
/* if y, do wavelet transform */
if (!sf_getbool("verb",&verb)) verb=true;
/* verbosity flag */
if (!sf_getfloat("eps",&eps)) eps=0.01;
/* regularization */
pp = sf_complexalloc(nh); /* data space */
qq = sf_complexalloc(nh); /* model space */
if (NULL == (type=sf_getstring("type"))) type="biorthogonal";
/* [haar,linear,biorthogonal] wavelet type, the default is biorthogonal */
fkoclet_init(nh,nk,dh,dk,dw,h0,k0,inv,false,dwt,eps*eps,type[0]);
/* loop over n4 */
for (i4=0; i4 < n4; i4++) {
for (iw=0; iw < nw; iw++) { /* loop over frequency */
if (verb) sf_warning("frequency %d of %d;",iw+1,nw);
w = w0 + iw*dw;
for (ik=0; ik < nk; ik++) { /* loop over wavenumber */
k = k0 + ik*dk;
if (adj) {
sf_complexread(qq,nh,in);
} else {
sf_complexread(pp,nh,in);
}
if (adj) {
fkoclet_lop(false,false,nh,nh,qq,pp,w,k);
sf_complexwrite(pp,nh,out);
} else {
fkoclet_lop(true,false,nh,nh,qq,pp,w,k);
sf_complexwrite(qq,nh,out);
}
}
}
}
sf_warning(".");
exit(0);
}
int main(int argc, char* argv[])
{
int it,i1,i2; /* index variables */
int nt,n12,ft,jt;
float dt,d1,d2,dt2;
float *ww,**vv,**rr;
float **u0,**u1,**u2,**ud;
sf_file Fw,Fv,Fr,Fo; /* I/O files */
/* initialize Madagascar */
sf_init(argc,argv);
/* initialize OpenMP support */
omp_init();
/* setup I/O files */
Fr = sf_input ("in"); /* source position */
Fo = sf_output("out"); /* output wavefield */
Fw = sf_input ("wav"); /* source wavelet */
Fv = sf_input ("v"); /* velocity */
/* Read/Write axes */
if (!sf_histint(Fr,"n1",&n1)) sf_error("No n1= in inp");
if (!sf_histint(Fr,"n2",&n2)) sf_error("No n2= in inp");
if (!sf_histfloat(Fr,"d1",&d1)) sf_error("No d1= in inp");
if (!sf_histfloat(Fr,"d2",&d2)) sf_error("No d2= in inp");
if (!sf_histint(Fw,"n1",&nt)) sf_error("No n1= in wav");
if (!sf_histfloat(Fw,"d1",&dt)) sf_error("No d1= in wav");
n12 = n1*n2;
if (!sf_getint("ft",&ft)) ft=0;
/* first recorded time */
if (!sf_getint("jt",&jt)) jt=1;
/* time interval */
sf_putint(Fo,"n3",(nt-ft)/jt);
sf_putfloat(Fo,"d3",jt*dt);
sf_putfloat(Fo,"o3",ft*dt);
dt2 = dt*dt;
/* set Laplacian coefficients */
d1 = 1.0/(d1*d1);
d2 = 1.0/(d2*d2);
c11 = 4.0*d1/3.0;
c12= -d1/12.0;
c21 = 4.0*d2/3.0;
c22= -d2/12.0;
c0 = -2.0 * (c11+c12+c21+c22);
/* read wavelet, velocity & source position */
ww=sf_floatalloc(nt); sf_floatread(ww ,nt ,Fw);
vv=sf_floatalloc2(n1,n2); sf_floatread(vv[0],n12,Fv);
rr=sf_floatalloc2(n1,n2); sf_floatread(rr[0],n12,Fr);
/* allocate temporary arrays */
u0=sf_floatalloc2(n1,n2);
u1=sf_floatalloc2(n1,n2);
u2=sf_floatalloc2(n1,n2);
ud=sf_floatalloc2(n1,n2);
for (i2=0; i2<n2; i2++) {
for (i1=0; i1<n1; i1++) {
u0[i2][i1]=0.0;
u1[i2][i1]=0.0;
u2[i2][i1]=0.0;
ud[i2][i1]=0.0;
vv[i2][i1] *= vv[i2][i1]*dt2;
}
}
/* Time loop */
for (it=0; it<nt; it++) {
laplacian(u1,ud);
#ifdef _OPENMP
#pragma omp parallel for \
private(i2,i1) \
shared(ud,vv,ww,it,rr,u2,u1,u0)
#endif
for (i2=0; i2<n2; i2++) {
for (i1=0; i1<n1; i1++) {
/* scale by velocity */
ud[i2][i1] *= vv[i2][i1];
/* inject wavelet */
ud[i2][i1] += ww[it] * rr[i2][i1];
/* time step */
u2[i2][i1] =
2*u1[i2][i1]
- u0[i2][i1]
+ ud[i2][i1];
u0[i2][i1] = u1[i2][i1];
u1[i2][i1] = u2[i2][i1];
}
}
/* write wavefield to output */
if (it >= ft && 0 == (it-ft)%jt) {
sf_warning("%d;",it+1);
sf_floatwrite(u1[0],n12,Fo);
}
}
sf_warning(".");
exit (0);
}
int main (int argc, char **argv)
{
int n1, nx, n3, dim, n[SF_MAX_DIM]; /* dimensions */
int i1, ix, i3, j; /* loop counters */
int nk; /* number of wavenumbers */
int npad; /* padding */
float dx; /* space sampling interval */
float dk; /* wavenumber sampling interval */
float x0; /* staring space */
float k0; /* starting wavenumber */
float wt; /* Fourier scaling */
kiss_fft_cpx **cp; /* frequency-wavenumber */
bool inv; /* forward or inverse */
bool sym; /* symmetric scaling */
bool opt; /* optimal padding */
int sign; /* transform sign */
int axis; /* transform axis */
char varname[12]; /* variable name */
char *label; /* transformed axis label */
#ifdef SF_HAS_FFTW
fftwf_plan cfg;
#else
kiss_fft_cpx *ctrace;
kiss_fft_cfg cfg;
#endif
sf_file in=NULL, out=NULL;
sf_init(argc,argv);
in = sf_input ( "in");
out = sf_output("out");
if (SF_COMPLEX != sf_gettype(in)) sf_error ("Need complex input");
if (!sf_getbool("inv",&inv)) inv = false;
/* if y, perform inverse transform */
if (!sf_getbool("sym",&sym)) sym=false;
/* if y, apply symmetric scaling to make the FFT operator Hermitian */
if (!sf_getint("sign",&sign)) sign = inv? 1: 0;
/* transform sign (0 or 1) */
if (!sf_getbool("opt",&opt)) opt=true;
/* if y, determine optimal size for efficiency */
if (!sf_getint("axis",&axis)) axis=2;
/* Axis to transform */
dim = sf_filedims(in,n);
n1=n3=1;
for (j=0; j < dim; j++) {
if (j < axis-1) n1 *= n[j];
else if (j > axis-1) n3 *= n[j];
}
if (inv) {
sprintf(varname,"n%d",axis);
if (!sf_histint (in,varname,&nk)) sf_error("No %s= in input",varname);
sprintf(varname,"d%d",axis);
if (!sf_histfloat(in,varname,&dk)) sf_error("No %s= in input",varname);
sprintf(varname,"fft3_n%d",axis);
if (!sf_histint (in,varname,&nx)) nx=nk;
sprintf(varname,"fft3_o%d",axis);
if (!sf_histfloat(in,varname,&x0)) x0 = 0.;
sprintf(varname,"fft3_label%d",axis);
label = sf_histstring(in,varname);
dx = 1./(nk*dk);
sprintf(varname,"n%d",axis);
sf_putint (out,varname,nx);
sprintf(varname,"d%d",axis);
sf_putfloat (out,varname,dx);
sprintf(varname,"o%d",axis);
sf_putfloat (out,varname,x0);
sprintf(varname,"label%d",axis);
if (NULL != label) {
sf_putstring(out,varname,label);
} else if (NULL != (label = sf_histstring(in,varname))) {
(void) sf_fft_label(axis,label,out);
}
} else {
sprintf(varname,"n%d",axis);
if (!sf_histint (in,varname,&nx)) sf_error("No %s= in input",varname);
sprintf(varname,"d%d",axis);
if (!sf_histfloat(in,varname,&dx)) sf_error("No %s= in input",varname);
sprintf(varname,"o%d",axis);
if (!sf_histfloat(in,varname,&x0)) x0 = 0.;
sprintf(varname,"label%d",axis);
label = sf_histstring(in,varname);
sprintf(varname,"fft3_n%d",axis);
sf_putint(out,varname,nx);
sprintf(varname,"fft3_o%d",axis);
sf_putfloat(out,varname,x0);
if (NULL != label) {
sprintf(varname,"fft3_label%d",axis);
sf_putstring(out,varname,label);
}
if (!sf_getint("pad",&npad)) npad=2;
/* padding factor */
/* determine wavenumber sampling */
nk = opt? kiss_fft_next_fast_size(nx*npad): nx*npad;
if (nk != nx) sf_warning("padded to %d",nk);
dk = 1./(nk*dx);
k0 = -0.5/dx;
sprintf(varname,"n%d",axis);
sf_putint (out,varname,nk);
sprintf(varname,"d%d",axis);
sf_putfloat (out,varname,dk);
sprintf(varname,"o%d",axis);
sf_putfloat (out,varname,k0);
if (NULL != label && !sf_fft_label(axis,label,out)) {
sprintf(varname,"label%d",axis);
sf_putstring(out,varname,"Wavenumber");
}
}
sprintf(varname,"unit%d",axis);
sf_fft_unit(axis,sf_histstring(in,varname),out);
cp = (kiss_fft_cpx**) sf_complexalloc2(n1,nk);
#ifdef SF_HAS_FFTW
ix = nk;
cfg = fftwf_plan_many_dft(1, &ix, n1,
(fftwf_complex*) cp[0], NULL, n1, 1,
(fftwf_complex*) cp[0], NULL, n1, 1,
sign? FFTW_BACKWARD: FFTW_FORWARD,
FFTW_ESTIMATE);
if (NULL == cfg) sf_error("FFTW failure.");
#else
ctrace = (kiss_fft_cpx*) sf_complexalloc(nk);
cfg = kiss_fft_alloc(nk,sign,NULL,NULL);
#endif
/* FFT scaling */
wt = sym? 1./sqrtf((float) nk): 1./nk;
for (i3=0; i3<n3; i3++) {
if (inv) {
sf_floatread((float*) cp[0],n1*nk*2,in);
#ifdef SF_HAS_FFTW
fftwf_execute(cfg);
for (ix=0; ix<nx; ix++) {
for (i1=0; i1 < n1; i1++) {
cp[ix][i1] = sf_crmul(cp[ix][i1],ix%2? -wt: wt);
}
}
#else
for (i1=0; i1 < n1; i1++) {
/* Fourier transform k to x */
kiss_fft_stride(cfg,cp[0]+i1,ctrace,n1);
for (ix=0; ix<nx; ix++) {
cp[ix][i1] = sf_crmul(ctrace[ix],ix%2? -wt: wt);
}
}
#endif
sf_floatwrite((float*) cp[0],n1*nx*2,out);
} else {
sf_floatread((float*) cp[0],n1*nx*2,in);
/* FFT centering */
for (ix=1; ix<nx; ix+=2) {
for (i1=0; i1<n1; i1++) {
cp[ix][i1] = sf_cneg(cp[ix][i1]);
}
}
if (sym) {
for (ix=0; ix<nx; ix++) {
for (i1=0; i1 < n1; i1++) {
cp[ix][i1] = sf_crmul(cp[ix][i1],wt);
}
}
}
/* pad with zeros */
for (ix=nx; ix<nk; ix++) {
for (i1=0; i1<n1; i1++) {
cp[ix][i1].r = 0.;
cp[ix][i1].i = 0.;
}
}
#ifdef SF_HAS_FFTW
fftwf_execute(cfg);
#else
for (i1=0; i1 < n1; i1++) {
/* Fourier transform x to k */
kiss_fft_stride(cfg,cp[0]+i1,ctrace,n1);
/* Transpose */
for (ix=0; ix<nk; ix++) {
cp[ix][i1] = ctrace[ix];
}
}
#endif
sf_floatwrite((float*) cp[0],n1*nk*2,out);
}
}
exit (0);
}
int main(int argc, char* argv[])
{
bool velocity, verb, shape;
int dim, i, j, n[3], rect[3], it, nt, order, nt0, nx0;
int iter, niter, iline, nline, cgiter, *f0, *m0=NULL;
float d[3], o[3], dt0, dx0, ot0, ox0, eps, tol, *p=NULL, *p0=NULL, thres;
float *vd, *vdt, *vdx, *s, *t0, *x0, *ds, *rhs, *rhs0, *rhs1=NULL, error0, error1, error, scale;
char key[6];
sf_file in, out, dix, t_0=NULL, x_0=NULL, f_0=NULL, grad=NULL, cost=NULL, mini=NULL, prec=NULL;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
/* read input dimension */
dim = sf_filedims(in,n);
nt = 1;
for (i=0; i < dim; i++) {
sprintf(key,"d%d",i+1);
if (!sf_histfloat(in,key,d+i)) sf_error("No %s= in input",key);
sprintf(key,"o%d",i+1);
if (!sf_histfloat(in,key,o+i)) o[i]=0.;
nt *= n[i];
}
if (dim < 3) {
n[2] = 1; d[2] = d[1]; o[2] = o[1];
}
/* read initial guess */
s = sf_floatalloc(nt);
sf_floatread(s,nt,in);
if (!sf_getbool("velocity",&velocity)) velocity=true;
/* y, input is velocity / n, slowness-squared */
if (velocity) {
for (it=0; it < nt; it++) {
s[it] = 1./s[it]*1./s[it];
}
}
/* read Dix velocity */
if (NULL == sf_getstring("dix")) sf_error("No Dix input dix=");
dix = sf_input("dix");
if(!sf_histint(dix,"n1",&nt0)) sf_error("No n1= in dix");
if(!sf_histint(dix,"n2",&nx0)) sf_error("No n2= in dix");
if(!sf_histfloat(dix,"d1",&dt0)) sf_error("No d1= in dix");
if(!sf_histfloat(dix,"d2",&dx0)) sf_error("No d2= in dix");
if(!sf_histfloat(dix,"o1",&ot0)) sf_error("No o1= in dix");
if(!sf_histfloat(dix,"o2",&ox0)) sf_error("No o2= in dix");
vd = sf_floatalloc(nt0*nx0);
sf_floatread(vd,nt0*nx0,dix);
sf_fileclose(dix);
/* Dix velocity derivative in t0 (2nd order FD) */
vdt = sf_floatalloc(nt0*nx0);
for (i=0; i < nt0; i++) {
for (j=0; j < nx0; j++) {
if (i == 0)
vdt[j*nt0+i] = (-vd[j*nt0+i+2]+4.*vd[j*nt0+i+1]-3.*vd[j*nt0+i])/(2.*dt0);
else if (i == nt0-1)
vdt[j*nt0+i] = (3.*vd[j*nt0+i]-4.*vd[j*nt0+i-1]+vd[j*nt0+i-2])/(2.*dt0);
else
vdt[j*nt0+i] = (vd[j*nt0+i+1]-vd[j*nt0+i-1])/(2.*dt0);
}
}
/* Dix velocity derivative in x0 (2nd order FD) */
vdx = sf_floatalloc(nt0*nx0);
for (j=0; j < nx0; j++) {
for (i=0; i < nt0; i++) {
if (j == 0)
vdx[j*nt0+i] = (-vd[(j+2)*nt0+i]+4.*vd[(j+1)*nt0+i]-3.*vd[j*nt0+i])/(2.*dx0);
else if (j == nx0-1)
vdx[j*nt0+i] = (3.*vd[j*nt0+i]-4.*vd[(j-1)*nt0+i]+vd[(j-2)*nt0+i])/(2.*dx0);
else
vdx[j*nt0+i] = (vd[(j+1)*nt0+i]-vd[(j-1)*nt0+i])/(2.*dx0);
}
}
if (!sf_getint("order",&order)) order=1;
/* fastmarch accuracy order */
if (!sf_getfloat("thres",&thres)) thres=10.;
/* thresholding for caustics */
if (!sf_getint("niter",&niter)) niter=1;
/* number of nonlinear updates */
if (!sf_getint("cgiter",&cgiter)) cgiter=200;
/* number of CG iterations */
if (!sf_getbool("shape",&shape)) shape=false;
/* regularization (default Tikhnov) */
if (!sf_getfloat("eps",&eps)) eps=0.1;
/* regularization parameter */
if (!sf_getint("nline",&nline)) nline=0;
/* maximum number of line search (default turned-off) */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
if (shape) {
if (!sf_getfloat("tol",&tol)) tol=1.e-6;
/* tolerance for shaping regularization */
for (i=0; i < dim; i++) {
sprintf(key,"rect%d",i+1);
if (!sf_getint(key,rect+i)) rect[i]=1;
/*( rect#=(1,1,...) smoothing radius on #-th axis )*/
}
/* triangle smoothing operator */
sf_trianglen_init(dim,rect,n);
sf_repeat_init(nt,1,sf_trianglen_lop);
sf_conjgrad_init(nt,nt,nt,nt,eps,tol,verb,false);
p = sf_floatalloc(nt);
} else {
/* initialize 2D gradient operator */
sf_igrad2_init(n[0],n[1]);
}
/* allocate memory for fastmarch */
t0 = sf_floatalloc(nt);
x0 = sf_floatalloc(nt);
f0 = sf_intalloc(nt);
/* allocate memory for update */
ds = sf_floatalloc(nt);
rhs = sf_floatalloc(nt);
/* output transformation matrix */
if (NULL != sf_getstring("t0")) {
t_0 = sf_output("t0");
sf_putint(t_0,"n3",niter+1);
}
if (NULL != sf_getstring("x0")) {
x_0 = sf_output("x0");
sf_putint(x_0,"n3",niter+1);
}
/* output auxiliary label */
if (NULL != sf_getstring("f0")) {
f_0 = sf_output("f0");
sf_settype(f_0,SF_INT);
sf_putint(f_0,"n3",niter+1);
}
/* output gradient */
if (NULL != sf_getstring("grad")) {
grad = sf_output("grad");
sf_putint(grad,"n3",niter);
}
/* output cost */
if (NULL != sf_getstring("cost")) {
cost = sf_output("cost");
sf_putint(cost,"n3",niter+1);
}
/* read mask (desired minimum) */
m0 = sf_intalloc(nt);
if (NULL != sf_getstring("mask")) {
mini = sf_input("mask");
sf_intread(m0,nt,mini);
sf_fileclose(mini);
} else {
for (it=0; it < nt; it++) m0[it] = -1;
}
/* read cost (desired minimum) */
rhs0 = sf_floatalloc(nt);
if (NULL != sf_getstring("mval")) {
mini = sf_input("mval");
sf_floatread(rhs0,nt,mini);
sf_fileclose(mini);
} else {
for (it=0; it < nt; it++) rhs0[it] = 0.;
}
/* read preconditioner */
if (NULL != sf_getstring("prec")) {
prec = sf_input("prec");
p0 = sf_floatalloc(nt);
sf_floatread(p0,nt,prec);
sf_fileclose(prec);
rhs1 = sf_floatalloc(nt);
}
/* fastmarch initialization */
fastmarch_init(n,o,d,order);
/* update initialization */
t2d_init(dim,n,d,nt0,dt0,ot0,nx0,dx0,ox0);
/* fastmarch */
fastmarch(t0,x0,f0,s);
/* caustic region (2D) */
t2d_caustic(x0,f0,n,d,thres);
/* set up operator */
t2d_set(t0,x0,f0,s,vd,vdt,vdx,m0,p0);
/* evaluate cost */
t2d_cost(rhs);
for (it=0; it < nt; it++) {
if (f0[it] >= 0 || m0[it] >= 0)
rhs[it] = 0.;
else
rhs[it] -= rhs0[it];
}
if (p0 == NULL) {
error0 = error1 = cblas_snrm2(nt,rhs,1);
} else {
for (it=0; it < nt; it++) rhs1[it] = p0[it]*rhs[it];
error0 = error1 = cblas_snrm2(nt,rhs1,1);
}
/* write optional outputs */
if (NULL!=t_0) sf_floatwrite(t0,nt,t_0);
if (NULL!=x_0) sf_floatwrite(x0,nt,x_0);
if (NULL!=f_0) sf_intwrite(f0,nt,f_0);
if (NULL!=cost) sf_floatwrite(rhs,nt,cost);
sf_warning("Start conversion, cost %g",1.);
/* nonlinear loop */
for (iter=0; iter < niter; iter++) {
/* solve ds */
if (shape) {
if (p0 == NULL)
sf_conjgrad(NULL,t2d_oper,sf_repeat_lop,p,ds,rhs,cgiter);
else
sf_conjgrad(t2d_prec,t2d_oper,sf_repeat_lop,p,ds,rhs,cgiter);
} else {
sf_solver_reg(t2d_oper,sf_cgstep,sf_igrad2_lop,2*nt,nt,nt,ds,rhs,cgiter,eps,"verb",verb,"end");
sf_cgstep_close();
}
/* add ds */
for (it=0; it < nt; it++) {
s[it] = s[it]+ds[it]+0.25*ds[it]*ds[it]/s[it];
}
/* fastmarch */
fastmarch(t0,x0,f0,s);
/* caustic region (2D) */
t2d_caustic(x0,f0,n,d,thres);
/* set up operator */
t2d_set(t0,x0,f0,s,vd,vdt,vdx,m0,p0);
/* evaluate cost */
t2d_cost(rhs);
for (it=0; it < nt; it++) {
if (f0[it] >= 0 || m0[it] >= 0)
rhs[it] = 0.;
else
rhs[it] -= rhs0[it];
}
if (p0 == NULL) {
error = cblas_snrm2(nt,rhs,1);
} else {
for (it=0; it < nt; it++) rhs1[it] = p0[it]*rhs[it];
error = cblas_snrm2(nt,rhs1,1);
}
error = cblas_snrm2(nt,rhs,1);
/* line search */
if (nline > 0 && error >= error1) {
scale = 0.5;
for (iline=0; iline < nline; iline++) {
for (it=0; it < nt; it++) {
s[it] = s[it]+(scale*ds[it])+0.25*(scale*ds[it])*(scale*ds[it])/s[it];
}
fastmarch(t0,x0,f0,s);
t2d_caustic(x0,f0,n,d,thres);
t2d_set(t0,x0,f0,s,vd,vdt,vdx,m0,p0);
t2d_cost(rhs);
for (it=0; it < nt; it++) {
if (f0[it] >= 0 || m0[it] >= 0)
rhs[it] = 0.;
else
rhs[it] -= rhs0[it];
}
if (p0 == NULL) {
error = cblas_snrm2(nt,rhs,1);
} else {
for (it=0; it < nt; it++) rhs1[it] = p0[it]*rhs[it];
error = cblas_snrm2(nt,rhs1,1);
}
error = cblas_snrm2(nt,rhs,1);
if (error < error1) {
sf_warning("Exist line search %d of %d",iline+1,nline);
} else {
scale *= 0.5;
}
}
}
error1 = error;
/* write optional outputs */
if (NULL!=t_0) sf_floatwrite(t0,nt,t_0);
if (NULL!=x_0) sf_floatwrite(x0,nt,x_0);
if (NULL!=f_0) sf_intwrite(f0,nt,f_0);
if (NULL!=cost) sf_floatwrite(rhs,nt,cost);
if (NULL!=grad) sf_floatwrite(ds,nt,grad);
sf_warning("Cost after iteration %d: %g",iter+1,error/error0);
}
/* write output */
if (velocity) {
for (it=0; it < nt; it++) {
s[it] = 1./sqrtf(s[it]);
}
}
sf_floatwrite(s,nt,out);
exit(0);
}
int main(int argc, char* argv[])
{
int nx, ny, nz, nt, ix, iy, iz, it, nbt, nbb, nxl, nxr, nyl, nyr, nxb, nyb, nzb, isx, isy, isz;
float dt, dx, dy, dz, o1, o2, o3, o4;
float ***upold, ***upcur, ***vpold, ***vpcur, ***wpold, ***wpcur, *wav;
float ***usold, ***uscur, ***vsold, ***vscur, ***wsold, ***wscur, ***tmp;
float ***uu,***vv,***ww;
float ***vp, vp0, ***vs, vs0, ***vtmp ;
float ***aa, w, g1, g2, g3, czt, czb, cxl, cxr, cyl, cyr; /* top, bottom, left, right */
float ax, ay, az, factor;
sf_file fwavup, fwavvp, fwavwp, fwavus, fwavvs, fwavws, fwavu, fwavv, fwavw, fvelp, fvels, fsource ;
int opt; /* optimal padding */
int nkxyz,nkxx,nkyy,nkzz;
int snap,nsnap;
int cent =2;
float alpha=0.5;
float phi;
sf_init(argc,argv);
fvelp = sf_input("vp"); /* velocity */
fvels = sf_input("vs"); /* velocity */
fsource = sf_input("in"); /* source wavlet*/
fwavup = sf_output("out");
fwavvp = sf_output("wavvp");
fwavwp = sf_output("wavwp");
fwavus = sf_output("wavus");
fwavvs = sf_output("wavvs");
fwavws = sf_output("wavws");
fwavu = sf_output("wavu");
fwavv = sf_output("wavv");
fwavw = sf_output("wavw");
/* if (SF_FLOAT != sf_gettype(inp)) sf_error("Need float input"); */
if (SF_FLOAT != sf_gettype(fvelp)) sf_error("Need float input");
if (SF_FLOAT != sf_gettype(fvels)) sf_error("Need float input");
if (SF_FLOAT != sf_gettype(fsource)) sf_error("Need float input");
if (!sf_histint(fvelp,"n1",&nz)) sf_error("No n1= in input");
if (!sf_histfloat(fvelp,"d1",&dz)) sf_error("No d1= in input");
if (!sf_histint(fvelp,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histfloat(fvelp,"d2",&dx)) sf_error("No d2= in input");
if (!sf_histint(fvelp,"n3",&ny)) sf_error("No n3= in input");
if (!sf_histfloat(fvelp,"d3",&dy)) sf_error("No d3= in input");
if (!sf_histfloat(fvelp,"o1",&o1)) o1=0.0;
if (!sf_histfloat(fvelp,"o2",&o2)) o2=0.0;
if (!sf_histfloat(fvelp,"o3",&o3)) o3=0.0;
if (!sf_getint("opt",&opt)) opt=1;
/* if y, determine optimal size for efficiency */
if (!sf_getfloat("dt",&dt)) sf_error("Need dt input");
if (!sf_getint("nt",&nt)) sf_error("Need nt input");
if (!sf_getint("isx",&isx)) sf_error("Need isx input");
if (!sf_getint("isy",&isy)) sf_error("Need isy input");
if (!sf_getint("isz",&isz)) sf_error("Need isz input");
if (!sf_getint("nbt",&nbt)) nbt=44;
if (!sf_getint("nbb",&nbb)) nbb=44;
if (!sf_getint("nxl",&nxl)) nxl=44;
if (!sf_getint("nxr",&nxr)) nxr=44;
if (!sf_getint("nyl",&nyl)) nyl=44;
if (!sf_getint("nyr",&nyr)) nyr=44;
/* assume ABC pars are the same */
if (nbt != nbb || nxl != nxr ||nyl!=nyr|| nbt!=nxl || nbt!=nyl)
sf_error("ABC pars are not the same");
if (!sf_getfloat("czt",&czt)) czt = 0.01; /*decaying parameter*/
if (!sf_getfloat("czb",&czb)) czb = 0.01; /*decaying parameter*/
if (!sf_getfloat("cxl",&cxl)) cxl = 0.01; /*decaying parameter*/
if (!sf_getfloat("cxr",&cxr)) cxr = 0.01; /*decaying parameter*/
if (!sf_getfloat("cyl",&cxl)) cyl = 0.01; /*decaying parameter*/
if (!sf_getfloat("cyr",&cxr)) cyr = 0.01; /*decaying parameter*/
if (!sf_getint("snap",&snap)) snap=1;
nsnap=0;
for (it=0; it < nt; it++) {
if (it%snap == 0) nsnap++;
}
sf_putfloat(fwavup,"d1",dz);
sf_putfloat(fwavup,"d2",dx);
sf_putfloat(fwavup,"d3",dy);
sf_putfloat(fwavup,"d4",dt*snap);
sf_putfloat(fwavup,"o1",o1);
sf_putfloat(fwavup,"o2",o2);
sf_putfloat(fwavup,"o3",o3);
sf_putfloat(fwavup,"o4",0.0);
sf_putfloat(fwavvp,"d1",dz);
sf_putfloat(fwavvp,"d2",dx);
sf_putfloat(fwavvp,"d3",dy);
sf_putfloat(fwavvp,"d4",dt*snap);
sf_putfloat(fwavvp,"o1",o1);
sf_putfloat(fwavvp,"o2",o2);
sf_putfloat(fwavvp,"o3",o3);
sf_putfloat(fwavvp,"o4",0.0);
sf_putfloat(fwavwp,"d1",dz);
sf_putfloat(fwavwp,"d2",dx);
sf_putfloat(fwavwp,"d3",dy);
sf_putfloat(fwavwp,"d4",dt*snap);
sf_putfloat(fwavwp,"o1",o1);
sf_putfloat(fwavwp,"o2",o2);
sf_putfloat(fwavwp,"o3",o3);
sf_putfloat(fwavwp,"o4",0.0);
sf_putfloat(fwavus,"d1",dz);
sf_putfloat(fwavus,"d2",dx);
sf_putfloat(fwavus,"d3",dy);
sf_putfloat(fwavus,"d4",dt*snap);
sf_putfloat(fwavus,"o1",o1);
sf_putfloat(fwavus,"o2",o2);
sf_putfloat(fwavus,"o3",o3);
sf_putfloat(fwavus,"o4",0.0);
sf_putfloat(fwavvs,"d1",dz);
sf_putfloat(fwavvs,"d2",dx);
sf_putfloat(fwavvs,"d3",dy);
sf_putfloat(fwavvs,"d4",dt*snap);
sf_putfloat(fwavvs,"o1",o1);
sf_putfloat(fwavvs,"o2",o2);
sf_putfloat(fwavvs,"o3",o3);
sf_putfloat(fwavvs,"o4",0.0);
sf_putfloat(fwavws,"d1",dz);
sf_putfloat(fwavws,"d2",dx);
sf_putfloat(fwavws,"d3",dy);
sf_putfloat(fwavws,"d4",dt*snap);
sf_putfloat(fwavws,"o1",o1);
sf_putfloat(fwavws,"o2",o2);
sf_putfloat(fwavws,"o3",o3);
sf_putfloat(fwavws,"o4",0.0);
sf_putfloat(fwavu,"d1",dz);
sf_putfloat(fwavu,"d2",dx);
sf_putfloat(fwavu,"d3",dy);
sf_putfloat(fwavu,"d4",dt*snap);
sf_putfloat(fwavu,"o1",o1);
sf_putfloat(fwavu,"o2",o2);
sf_putfloat(fwavu,"o3",o3);
sf_putfloat(fwavu,"o4",0.0);
sf_putfloat(fwavv,"d1",dz);
sf_putfloat(fwavv,"d2",dx);
sf_putfloat(fwavv,"d3",dy);
sf_putfloat(fwavv,"d4",dt*snap);
sf_putfloat(fwavv,"o1",o1);
sf_putfloat(fwavv,"o2",o2);
sf_putfloat(fwavv,"o3",o3);
sf_putfloat(fwavv,"o4",0.0);
sf_putfloat(fwavw,"d1",dz);
sf_putfloat(fwavw,"d2",dx);
sf_putfloat(fwavw,"d3",dy);
sf_putfloat(fwavw,"d4",dt*snap);
sf_putfloat(fwavw,"o1",o1);
sf_putfloat(fwavw,"o2",o2);
sf_putfloat(fwavw,"o3",o3);
sf_putfloat(fwavw,"o4",0.0);
nxb = nx + nxl + nxr;
nyb = ny + nyl + nyr;
nzb = nz + nbt + nbb;
sf_putint(fwavup,"n1",nzb);
sf_putint(fwavup,"n2",nxb);
sf_putint(fwavup,"n3",nyb);
sf_putint(fwavup,"n4",nsnap);
sf_putint(fwavvp,"n1",nzb);
sf_putint(fwavvp,"n2",nxb);
sf_putint(fwavvp,"n3",nyb);
sf_putint(fwavvp,"n4",nsnap);
sf_putint(fwavwp,"n1",nzb);
sf_putint(fwavwp,"n2",nxb);
sf_putint(fwavwp,"n3",nyb);
sf_putint(fwavwp,"n4",nsnap);
sf_putint(fwavus,"n1",nzb);
sf_putint(fwavus,"n2",nxb);
sf_putint(fwavus,"n3",nyb);
sf_putint(fwavus,"n4",nsnap);
sf_putint(fwavvs,"n1",nzb);
sf_putint(fwavvs,"n2",nxb);
sf_putint(fwavvs,"n3",nyb);
sf_putint(fwavvs,"n4",nsnap);
sf_putint(fwavws,"n1",nzb);
sf_putint(fwavws,"n2",nxb);
sf_putint(fwavws,"n3",nyb);
sf_putint(fwavws,"n4",nsnap);
sf_putint(fwavu,"n1",nzb);
sf_putint(fwavu,"n2",nxb);
sf_putint(fwavu,"n3",nyb);
sf_putint(fwavu,"n4",nsnap);
sf_putint(fwavv,"n1",nzb);
sf_putint(fwavv,"n2",nxb);
sf_putint(fwavv,"n3",nyb);
sf_putint(fwavv,"n4",nsnap);
sf_putint(fwavw,"n1",nzb);
sf_putint(fwavw,"n2",nxb);
sf_putint(fwavw,"n3",nyb);
sf_putint(fwavw,"n4",nsnap);
wav = sf_floatalloc(nt);
sf_floatread(wav,nt,fsource);
upold = sf_floatalloc3(nzb,nxb,nyb);
upcur = sf_floatalloc3(nzb,nxb,nyb);
vpold = sf_floatalloc3(nzb,nxb,nyb);
vpcur = sf_floatalloc3(nzb,nxb,nyb);
wpold = sf_floatalloc3(nzb,nxb,nyb);
wpcur = sf_floatalloc3(nzb,nxb,nyb);
usold = sf_floatalloc3(nzb,nxb,nyb);
uscur = sf_floatalloc3(nzb,nxb,nyb);
vsold = sf_floatalloc3(nzb,nxb,nyb);
vscur = sf_floatalloc3(nzb,nxb,nyb);
wsold = sf_floatalloc3(nzb,nxb,nyb);
wscur = sf_floatalloc3(nzb,nxb,nyb);
uu = sf_floatalloc3(nzb,nxb,nyb);
vv = sf_floatalloc3(nzb,nxb,nyb);
ww = sf_floatalloc3(nzb,nxb,nyb);
aa = sf_floatalloc3(nzb,nxb,3);
bd3_init(ny,nx,nz,nyl,nyr,nxl,nxr,nbt,nbb,cyl,cyr,cxl,cxr,czt,czb);
/*input & extend velocity model*/
vp = sf_floatalloc3(nzb,nxb,nyb);
vtmp = sf_floatalloc3(nz,nx,ny);
sf_floatread(vtmp[0][0],nx*ny*nz,fvelp);
vp = extmodel3d(vtmp, nz, nx, ny, nbt);
vs = sf_floatalloc3(nzb,nxb,nyb);
sf_floatread(vtmp[0][0],nx*ny*nz,fvels);
vs= extmodel3d(vtmp, nz, nx, ny, nbt);
vp0 =0.0;
for (iy=0; iy < nyb; iy++) {
for (ix=0; ix < nxb; ix++) {
for (iz=0; iz < nzb; iz++) {
vp0 += vp[iy][ix][iz]*vp[iy][ix][iz];
}
}
}
vp0 = sqrtf(vp0/(nxb*nyb*nzb));
fprintf(stderr, "vp0=%f\n\n", vp0);
vs0 =0.0;
for (iy=0; iy < nyb; iy++) {
for (ix=0; ix < nxb; ix++) {
for (iz=0; iz < nzb; iz++) {
vs0 += vs[iy][ix][iz]*vs[iy][ix][iz];
}
}
}
vs0 = sqrtf(vs0/(nxb*nyb*nzb));
fprintf(stderr, "vs0=%f\n\n", vs0);
for (iy=0; iy < nyb; iy++) {
for (ix=0; ix < nxb; ix++) {
for (iz=0; iz < nzb; iz++) {
upcur[iy][ix][iz] = 0.0;
upold[iy][ix][iz] = 0.0;
vpcur[iy][ix][iz] = 0.0;
vpold[iy][ix][iz] = 0.0;
wpcur[iy][ix][iz] = 0.0;
wpold[iy][ix][iz] = 0.0;
uscur[iy][ix][iz] = 0.0;
usold[iy][ix][iz] = 0.0;
vscur[iy][ix][iz] = 0.0;
vsold[iy][ix][iz] = 0.0;
wscur[iy][ix][iz] = 0.0;
wsold[iy][ix][iz] = 0.0;
uu[iy][ix][iz] = 0.0;
vv[iy][ix][iz] = 0.0;
ww[iy][ix][iz] = 0.0;
}
}
}
/* propagation in time */
pamstep3e_init(nzb,nxb,nyb,dz,dx,dy,opt);
nkxyz=fft3_init(true,1,nzb,nxb,nyb,&nkzz,&nkxx,&nkyy);
for (it=0; it < nt; it++) {
fprintf(stderr, "\b\b\b\b\b%d", it);
// uu[isx+nxl][isz+nbt] += wav[it];
// ww[isx+nxl][isz+nbt] += wav[it];
pamstep3e(upold, upcur, vpold, vpcur, wpold, wpcur, usold, uscur, vsold, vscur, wsold, wscur, uu, vv, ww, nzb, nxb, nyb, dz, dx, dy, vp0, vs0, vp, vs, dt);
for (iy=0; iy < nyb; iy++) {
for (ix=0; ix < nxb; ix++) {
for (iz=0; iz < nzb; iz++) {
uu[iy][ix][iz] = upold[iy][ix][iz] + usold[iy][ix][iz];
vv[iy][ix][iz] = vpold[iy][ix][iz] + vsold[iy][ix][iz];
ww[iy][ix][iz] = wpold[iy][ix][iz] + wsold[iy][ix][iz];
}
}
}
for (iy=0; iy < 2*cent; iy++) {
for (ix=0; ix < 2*cent; ix++) {
for (iz=0; iz < 2*cent; iz++) {
phi = exp(-alpha*alpha*((ix-cent)*(ix-cent) + (iy-cent)*(iy-cent) + (iz-cent)*(iz-cent)));
uu[isy+nyl-cent+iy][isx+nxl-cent+ix][isz+nbt-cent+iz] += phi*wav[it]*dt;
}
}
}
// uu[isy+nyl][isx+nxl][isz+nbt] += wav[it];
// ww[isx+nxl][isz+nbt] += wav[it];
bd3_decay(upold);
bd3_decay(upcur);
bd3_decay(usold);
bd3_decay(uscur);
bd3_decay(vpold);
bd3_decay(vpcur);
bd3_decay(vsold);
bd3_decay(vscur);
bd3_decay(wpold);
bd3_decay(wpcur);
bd3_decay(wsold);
bd3_decay(wscur);
tmp = upold;
upold = upcur;
upcur = tmp;
tmp = vpold;
vpold = vpcur;
vpcur = tmp;
tmp = wpold;
wpold = wpcur;
wpcur = tmp;
tmp = usold;
usold = uscur;
uscur = tmp;
tmp = vsold;
vsold = vscur;
vscur = tmp;
tmp = wsold;
wsold = wscur;
wscur = tmp;
if (it%snap == 0) {
sf_floatwrite(upcur[0][0], nxb*nyb*nzb, fwavup);
sf_floatwrite(vpcur[0][0], nxb*nyb*nzb, fwavvp);
sf_floatwrite(wpcur[0][0], nxb*nyb*nzb, fwavwp);
sf_floatwrite(uscur[0][0], nxb*nyb*nzb, fwavus);
sf_floatwrite(vscur[0][0], nxb*nyb*nzb, fwavvs);
sf_floatwrite(wscur[0][0], nxb*nyb*nzb, fwavws);
sf_floatwrite(uu[0][0], nxb*nyb*nzb, fwavu);
sf_floatwrite(vv[0][0], nxb*nyb*nzb, fwavv);
sf_floatwrite(ww[0][0], nxb*nyb*nzb, fwavw);
}
}
pamstep3e_close();
bd3_close();
free(**aa);
free(*aa);
free(aa);
free(**vp);
free(**vtmp);
free(**upcur);
free(**upold);
free(**vpcur);
free(**vpold);
free(**wpcur);
free(**wpold);
free(**uscur);
free(**usold);
free(**vscur);
free(**vsold);
free(**wscur);
free(**wsold);
free(*vp);
free(*vtmp);
free(*upcur);
free(*upold);
free(*vpcur);
free(*vpold);
free(*wpcur);
free(*wpold);
free(*uscur);
free(*usold);
free(*vscur);
free(*vsold);
free(*wscur);
free(*wsold);
free(vp);
free(vtmp);
free(upcur);
free(upold);
free(vpcur);
free(vpold);
free(wpcur);
free(wpold);
free(uscur);
free(usold);
free(vscur);
free(vsold);
free(wscur);
free(wsold);
fprintf(stderr, "Done\n");
exit(0);
}
int main(int argc, char* argv[])
{
int nx, nt, nk, ik, ix, it, nft;
float dt, dx, dk, k;
float *old, *nxt, *cur, *sig, *v, *nxttmp, v0, **aa, tv, tv0, dv, pi=SF_PI, tmpk;
sf_file in, out, vel;
bool opt; /* optimal padding */
sf_complex *uk, *uktmp;
kiss_fftr_cfg cfg, cfgi;
sf_init(argc,argv);
in = sf_input("in");
vel = sf_input("vel"); /* velocity */
out = sf_output("out");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if (SF_FLOAT != sf_gettype(vel)) sf_error("Need float input");
if (!sf_histint(vel,"n1",&nx)) sf_error("No n1= in input");
if (!sf_histfloat(vel,"d1",&dx)) sf_error("No d1= in input");
if (!sf_getbool("opt",&opt)) opt=true;
if (!sf_getfloat("dt",&dt)) sf_error("Need dt input");
if (!sf_getint("nt",&nt)) sf_error("Need nt input");
sf_putint(out,"n1",nx);
sf_putfloat(out,"d1",dx);
// sf_putfloat(out,"o1",x0);
sf_putint(out,"n2",nt);
sf_putfloat(out,"d2",dt);
sf_putfloat(out,"o2",0.0);
nft = opt? 2*kiss_fft_next_fast_size((nx+1)/2): nx;
if (nft%2) nft++;
nk = nft/2+1;
dk = 1./(nft*dx);
sig = sf_floatalloc(nx);
old = sf_floatalloc(nx);
nxt = sf_floatalloc(nx);
nxttmp = sf_floatalloc(nx);
cur = sf_floatalloc(nx);
v = sf_floatalloc(nx);
aa = sf_floatalloc2(2,nx);
uk = sf_complexalloc(nk);
uktmp = sf_complexalloc(nk);
sf_floatread(v,nx,vel);
sf_floatread(sig,nx,in);
sf_floatwrite(sig,nx,out);
v0=0.0;
for (ix=0; ix < nx; ix++) v0 += v[ix]*v[ix];
v0 /= (float)nx;
/* v0 RMS velocity*/
v0 = sqrt(v0);
tv0 = v0*v0*dt*dt;
for (ix=0; ix < nx; ix++){
tv = dt*dt*v[ix]*v[ix];
dv = (v[ix]*v[ix]-v0*v0)*dt*dt/(dx*dx);
aa[ix][0] = tv*(1.0 - dv/6.0);
aa[ix][1] = tv*dv/12.0;
}
/* initial conditions */
for (ix=0; ix < nx; ix++){
cur[ix] = sig[ix];
old[ix] = 0.0;
nxt[ix] = 0.;
}
free(v);
free(sig);
cfg = kiss_fftr_alloc(nft,0,NULL,NULL);
cfgi = kiss_fftr_alloc(nft,1,NULL,NULL);
/* propagation in time */
for (it=1; it < nt; it++) {
kiss_fftr(cfg,cur,(kiss_fft_cpx*)uk);/*compute u(k) */
#ifdef SF_HAS_COMPLEX_H
for (ik=0; ik < nk; ik++) {
k = ik * dk*2.0*pi;
tmpk = v0*fabs(k)*dt;
uktmp[ik] = uk[ik]*2.0*(cosf(tmpk)-1.0)/tv0;
}
#else
for (ik=0; ik < nk; ik++) {
k = ik * dk*2.0*pi;
tmpk = v0*fabs(k)*dt;
uktmp[ik] = sf_crmul(uk[ik],2.0*(cosf(tmpk)-1.0)/tv0);
}
#endif
kiss_fftri(cfgi,(kiss_fft_cpx*)uktmp,nxttmp);
for (ix=0; ix < nx; ix++) nxttmp[ix] /= (float)nft;
/* Stencil */
nxt[0] = nxttmp[0]*aa[0][0] + nxttmp[0]*aa[0][0] + nxttmp[1]*aa[0][1];
for (ix=1; ix < nx-1; ix++) {
nxt[ix] = nxttmp[ix]*aa[ix][0] + nxttmp[ix+1]*aa[ix][1] + nxttmp[ix-1]*aa[ix][1];
}
nxt[nx-1] = nxttmp[nx-1]*aa[nx-1][1] + nxttmp[nx-1]*aa[nx-1][0] + nxttmp[nx-2]*aa[nx-1][1];
for (ix=0; ix < nx; ix++) {
nxt[ix] += 2*cur[ix] - old[ix];
}
sf_floatwrite(nxt,nx,out);
for (ix=0; ix < nx; ix++) {
old[ix] = cur[ix];
cur[ix] = nxt[ix];
}
}
exit(0);
}
int main(int argc, char* argv[])
{
int verbose;
sf_file in=NULL, out=NULL;
int n1_traces;
int n1_headers;
char* header_format=NULL;
sf_datatype typehead;
/* kls do I need to add this? sf_datatype typein; */
float* fheader=NULL;
float* intrace=NULL;
int numkeys;
int ikey;
char** list_of_keys;
int *indx_of_keys;
int indx_time;
bool pkeychanged;
float* stktrace=NULL;
float* stkheader=NULL;
float* time_variant_fold=NULL;
int eof_get_tah;
int fold;
int itrace=0;
int ntaper;
int numxmute;
int numtmute;
float* taper;
char **list_of_floats;
float* xmute;
float* tmute;
int indx_of_offset;
float offset;
float d1;
float o1;
float mute_start;
int imute_start;
int indx_taper;
/*****************************/
/* initialize verbose switch */
/*****************************/
sf_init (argc,argv);
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 */
/******************************************/
if(verbose>0)fprintf(stderr,"read in file name\n");
in = sf_input ("in");
if(verbose>0)fprintf(stderr,"read out file name\n");
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");
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);
if(verbose>0)fprintf(stderr,"allocate intrace. n1_traces=%d\n",n1_traces);
intrace= sf_floatalloc(n1_traces);
if(verbose>0)fprintf(stderr,"call list of keys\n");
if(!(list_of_keys=sf_getnstring("key",&numkeys)))
fprintf(stderr,"key not input\n");
/* List of header keys to monitor to determine when to break between
gathers. A gather is a sequence of traces with the same value for
all the header keys. Stack summs traces in the gather, divides
by the fold, and outputs the stack trace. */
if(verbose>0)fprintf(stderr,"after sf_getnstring\n");
if(list_of_keys==NULL)
sf_error("The required parameter \"key\" was not found.");
/* I wanted to use sf_getstrings, but it seems to want a colon seperated
list of keys (eg key=offset:ep:fldr:cdp) and I wanted a comma seperated
list of keys (eg key=offset:ep:fldr:cdp).
numkeys=sf_getnumpars("key");
if(numkeys==0)
sf_error("The required parameter \"key\" was not found.");
fprintf(stderr,"alloc list_of_keys numkeys=%d\n",numkeys);
list_of_keys=(char**)sf_alloc(numkeys,sizeof(char*));
sf_getstrings("key",list_of_keys,numkeys);
*/
/* print the list of keys */
if(verbose>1){
fprintf(stderr,"numkeys=%d\n",numkeys);
for(ikey=0; ikey<numkeys; ikey++){
fprintf(stderr,"list_of_keys[%d]=%s\n",ikey,list_of_keys[ikey]);
}
}
/* maybe I should add some validation that n1== n1_traces+n1_headers+2
and the record length read in the second word is consistent with
n1. */
/**********************************************************/
/* end code block for standard tah Trace And Header setup */
/* continue with any sf_puthist this tah program calls to */
/* add to the history file */
/**********************************************************/
/* put the history from the input file to the output */
sf_fileflush(out,in);
/********************************************************/
/* continue initialization specific to this tah program */
/********************************************************/
/* segy_init gets the list header keys required by segykey function */
segy_init(n1_headers,in);
indx_of_keys=sf_intalloc(numkeys);
for (ikey=0; ikey<numkeys; ikey++){
/* kls need to check each of these key names are in the segy header and
make error message for invalid keys. Of does segykey do this? NO, just
segmentation fault. */
indx_of_keys[ikey]=segykey(list_of_keys[ikey]);
}
/* get the mute parameters */
if(NULL==(list_of_floats=sf_getnstring("xmute",&numxmute))){
xmute=NULL;
numxmute=0;
} else {
xmute=sf_floatalloc(numxmute);
if(!sf_getfloats("xmute",xmute,numxmute))sf_error("unable to read xmute");
}
if(NULL==(list_of_floats=sf_getnstring("tmute",&numtmute))){
tmute=NULL;
numtmute=0;
} else {
tmute=sf_floatalloc(numtmute);
if(!sf_getfloats("tmute",tmute,numtmute))sf_error("unable to read tmute");
}
if(numxmute!=numtmute)sf_error("bad mute parameters: numxmute!=numtmute");
if(numxmute<=0) {
ntaper=0;
indx_of_offset=0;
taper=NULL;
} else {
if(!sf_getint("ntaper",&ntaper))ntaper=12;
/* \n
length of the taper on the stack mute
*/
taper=sf_floatalloc(ntaper);
for(indx_time=0; indx_time<ntaper; indx_time++){
float val_sin=sin((indx_time+1)*SF_PI/(2*ntaper));
taper[indx_time]=val_sin*val_sin;
}
indx_of_offset=segykey("offset");
}
if (!sf_histfloat(in,"d1",&d1))
sf_error("input data does not define d1");
if (!sf_histfloat(in,"o1",&o1))
sf_error("input data does not define o1");
stktrace = sf_floatalloc(n1_traces);
stkheader = sf_floatalloc(n1_headers);
time_variant_fold = sf_floatalloc(n1_traces);
/***************************/
/* start trace loop */
/***************************/
if(verbose>0)fprintf(stderr,"start trace loop\n");
itrace=0;
eof_get_tah=get_tah(intrace, fheader, n1_traces, n1_headers, in);
fold=0;
while (!eof_get_tah){
if(verbose>1 && itrace<5)fprintf(stderr,"process the tah in sftahstack\n");
/********************/
/* process the tah. */
/********************/
/* this program stacks sequential traces with matching pkey. If one of the
headers in pkey changes, the summed trace is divided by the time
variant fold and output.
*/
if(fold==0){
memcpy(stkheader,fheader,n1_headers*sizeof(int));
for(indx_time=0; indx_time<n1_traces; indx_time++){
time_variant_fold[indx_time]=0.0;
stktrace[indx_time]=0.0;
}
}
if(xmute==NULL)mute_start=o1;
else{
if(typehead == SF_INT)offset=((int *)fheader)[indx_of_offset];
else offset=((float*)fheader)[indx_of_offset];
intlin(numxmute,xmute,tmute,
tmute[0],tmute[numxmute-1],1,
&offset,&mute_start);
if(mute_start<o1)mute_start=o1;
}
imute_start=(int)(((mute_start-o1)/d1)+.5);
if(0)fprintf(stderr,"imute_start=%d\n",imute_start);
for(; imute_start<n1_traces && intrace[imute_start]==0;
imute_start++); /* increate imute_start to first non-zero sample */
if(0)fprintf(stderr,"updated imute_start=%d\n",imute_start);
for(indx_time=imute_start, indx_taper=0;
indx_time<imute_start+ntaper && indx_time<n1_traces;
indx_time++, indx_taper++){
stktrace[indx_time]+=taper[indx_taper]*intrace[indx_time];
time_variant_fold[indx_time]+=taper[indx_taper];
}
for(; indx_time<n1_traces; indx_time++){
stktrace[indx_time]+=intrace[indx_time];
time_variant_fold[indx_time]++;
}
fold++;
eof_get_tah=get_tah(intrace, fheader, n1_traces, n1_headers, in);
/* did any of the header keys in indx_of_keys change? */
pkeychanged=false;
if(itrace>0){
for(ikey=0; ikey<numkeys; ikey++){
if(typehead == SF_INT){
if(((int*)fheader )[indx_of_keys[ikey]]!=
((int*)stkheader)[indx_of_keys[ikey]]){
pkeychanged=true;
break;
}
} else {
if(fheader[indx_of_keys[ikey]]!=stkheader[indx_of_keys[ikey]]){
pkeychanged=true;
break;
}
}
}
}
/* if one of the headers changes, apply fold recovery, output trace, and
set fold=0. Fold=0 will initialize the stktrace to zero at top f loop*/
if(pkeychanged){
/***********************************/
/* divide by the time variant fold */
/***********************************/
if(verbose>1)fprintf(stderr,"pkeychanged. divide by fold\n");
for(indx_time=0; indx_time<n1_traces; indx_time++){
if(time_variant_fold[indx_time]<1.0)time_variant_fold[indx_time]=1.0;
stktrace[indx_time]/=time_variant_fold[indx_time];
}
/* kls set any headers? Maybe fold? offset? */
/***************************/
/* write trace and headers */
/***************************/
if(verbose>1)fprintf(stderr,"put_tah\n");
put_tah(stktrace, stkheader, n1_traces, n1_headers, out);
fold=0;
}
itrace++;
}
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);
}
int main(int argc, char* argv[])
{
int nx, nt, ix, it, isx;
float dt, dx, dx2;
float *old, *nxt, *cur, *sig, *v;
sf_file in, out, vel;
int im,im2,im3,im4,im5,ip,ip2,ip3,ip4,ip5;
float a, b1, b2, b3, b4, b5;
sf_init(argc,argv);
in = sf_input("in");
vel = sf_input("vel"); /* velocity */
out = sf_output("out");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if (!sf_histint(vel,"n1",&nx)) sf_error("No n1= in input");
if (!sf_histfloat(vel,"d1",&dx)) sf_error("No d1= in input");
if (!sf_getint("isx",&isx)) isx=(int)(nx/2);
if (!sf_getint("nt",&nt)) sf_error("No nt in input");
if (!sf_getfloat("dt",&dt)) sf_error("No dt in input");
sf_putint(out,"n1",nx);
sf_putfloat(out,"d1",dx);
sf_putint(out,"n2",nt);
sf_putfloat(out,"d2",dt);
sf_putfloat(out,"o2",0.0);
sig = sf_floatalloc(nx);
old = sf_floatalloc(nx);
nxt = sf_floatalloc(nx);
cur = sf_floatalloc(nx);
v = sf_floatalloc(nx);
sf_floatread(v,nx,vel);
sf_floatread(sig,nx,in);
/* initial conditions */
for (ix=0; ix < nx; ix++){
cur[ix] = sig[ix];
old[ix] = 0.0;
nxt[ix] = 0.;
}
dx2 = dx*dx;
b1 = 5.0/(3.0*dx2);
b2 = -5.0/(21.0*dx2);
b3 = 5.0/(126.0*dx2);
b4 = -5.0/(1008.0*dx2);
b5 = 1.0/(3150.0*dx2);
a = -2.0*(b1+b2+b3+b4+b5);
/* propagation in time */
for (it=0; it < nt; it++) {
sf_floatwrite(cur,nx,out);
/* Stencil */
/*
for (ix=0; ix < nx; ix++) {
im = (ix-1 < 0)? (ix-1+nx):(ix-1);
im2 = (ix-2 < 0)? (ix-2+nx):(ix-2);
im3 = (ix-3 < 0)? (ix-3+nx):(ix-3);
im4 = (ix-4 < 0)? (ix-4+nx):(ix-4);
im5 = (ix-5 < 0)? (ix-5+nx):(ix-5);
ip = (ix+1 > nx-1)? (ix+1-nx):(ix+1);
ip2 = (ix+2 > nx-1)? (ix+2-nx):(ix+2);
ip3 = (ix+3 > nx-1)? (ix+3-nx):(ix+3);
ip4 = (ix+4 > nx-1)? (ix+4-nx):(ix+4);
ip5 = (ix+5 > nx-1)? (ix+5-nx):(ix+5);
nxt[ix] = dt*dt*v[ix]*v[ix]*(a*cur[ix] +b1* (cur[im]+cur[ip])
+b2* (cur[im2]+cur[ip2])+b3* (cur[im3]+cur[ip3])
+b4* (cur[im4]+cur[ip4])+b5* (cur[im5]+cur[ip5]))
+2.0*cur[ix]- old[ix];
*/
for (ix=0; ix < nx; ix++) {
im =(ix-1+nx)%nx;
im2 =(ix-2+nx)%nx;
im3 =(ix-3+nx)%nx;
im4 =(ix-4+nx)%nx;
im5 =(ix-5+nx)%nx;
ip = (ix+1+nx)%nx;
ip2 =(ix+2+nx)%nx;
ip3 =(ix+3+nx)%nx;
ip4 =(ix+4+nx)%nx;
ip5 =(ix+5+nx)%nx;
nxt[ix] = dt*dt*v[ix]*v[ix]*(a*cur[ix] +b1* (cur[im]+cur[ip])
+b2* (cur[im2]+cur[ip2])+b3* (cur[im3]+cur[ip3])
+b4* (cur[im4]+cur[ip4])+b5* (cur[im5]+cur[ip5]))
+2.0*cur[ix]- old[ix];
}
for (ix=0; ix < nx; ix++) {
old[ix] = cur[ix];
cur[ix] = nxt[ix];
}
}
exit(0);
}
int main (int argc, char* argv[])
{
bool verb;
float o1,o2,d1,d2;
int n1, n2,n3, shift;
int i2,i3;
char *unit1,*label1;
float *column=NULL,*max=NULL;
int *index=NULL;
sf_file in=NULL,out=NULL,max_val=NULL;
sf_init (argc,argv);
in=sf_input("in");
out=sf_output("out");
sf_settype (out, SF_INT);
if (NULL != sf_getstring("max_val")) max_val=sf_output("max_val");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input");
if (!sf_histfloat(in,"o1",&o1)) sf_error("No o1= in input");
label1=sf_charalloc(100);
unit1=sf_charalloc(100);
label1=sf_histstring(in,"label2");
unit1=sf_histstring(in,"unit2");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
if (!sf_histfloat(in,"d2",&d2)) sf_error("No d2= in input");
if (!sf_histfloat(in,"o2",&o2)) sf_error("No o2= in input");
if (!sf_getint("shift",&shift)) shift=0;
/* shift */
if (!sf_getbool("verb",&verb)) verb=false;
column = sf_floatalloc(n1);
max = sf_floatalloc(n2);
index = sf_intalloc(n2);
sf_putint(out,"n1",n2);
sf_putfloat(out,"o1",o2);
sf_putfloat(out,"d1",d2);
if (!(label1==NULL)) sf_putstring(out,"label1",label1);
if (!(unit1==NULL)) sf_putstring(out,"unit1",unit1);
//sf_warning("Son qua d2=%s",label1);
sf_putint(out,"n2",1);
sf_putstring(out,"o2","");
sf_putstring(out,"d2","");
sf_putstring(out,"label2","");
sf_putstring(out,"unit2","");
if (!(max_val==NULL)) {
sf_putint(out,"n1",n2);
sf_putfloat(out,"o1",o2);
sf_putint(max_val,"n2",1);
sf_putstring(max_val,"o2","");
sf_putstring(max_val,"d2","");
sf_putstring(max_val,"label2","");
sf_putstring(max_val,"unit2","");
}
/* reading the number of gahters in data*/
n3 = sf_leftsize(in,2);
for (i3=0;i3<n3;i3++) { /*gahters loop */
sf_warning("Gather %d/%d",i3+1,n3);
for (i2=0;i2<n2;i2++) {
sf_floatread(column,n1,in);
max[i2]=find_max (column, n1, index+i2);
if (d1<0)
index[i2]=n1-index[i2]+shift;
else
index[i2]-=shift;
//sf_warning("Son qua, max=%f index=%d",max[i2],index[i2]);
}
if (!(max_val==NULL)) {
sf_floatwrite(max,n2,max_val);
}
sf_intwrite(index,n2,out);
} /* END gahters loop */
exit (0);
}
int main(int argc, char* argv[])
{
bool sorted;
int i1, n1, i2, n2, ip, np;
float o1, d1, t0, t1, t2, t, a, *trace=NULL;
float min, max, x;
sf_complex *pick=NULL;
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");
n2 = sf_leftsize(in,1);
if (!sf_histfloat(in,"d1",&d1)) d1=1.;
if (!sf_histfloat(in,"o1",&o1)) o1=0.;
if (!sf_getfloat("min",&min)) min=o1;
/* minimum value of time */
if (!sf_getfloat("max",&max)) max=o1+(n1-1)*d1;
/* maximum value of time */
if (!sf_getint("np",&np)) np=n1;
/* maximum number of picks */
if (!sf_getbool("sorted",&sorted)) sorted=true;
/* if y, sort by amplitude */
sf_putint(out,"n1",np);
sf_settype(out,SF_COMPLEX);
trace = sf_floatalloc(n1);
pick = sf_complexalloc(np);
for (i2=0; i2 < n2; i2++) {
sf_floatread(trace,n1,in);
t0 = trace[0];
t1 = trace[1];
ip = 0;
for (i1=2; i1 < n1; i1++) {
t2 = trace[i1];
if (ip < np && t1 > t0 && t1 > t2) {
/* parabolic approximation */
t = 0.5*(t2-t0)/(2*t1-t0-t2);
a = t1+0.25*(t2-t0)*t;
if (t < -1.) {
t=-1;
a=t0;
} else if (t > 1.) {
t=1.;
a=t2;
}
x = o1+(i1-1+t)*d1;
if (x >= min && x <= max) {
pick[ip] = sf_cmplx(x,a);
ip++;
}
}
t0 = t1;
t1 = t2;
}
if (0==ip) {
pick[0] = sf_cmplx(o1-d1,0.);
ip++;
}
if (sorted) qsort(pick,ip,sizeof(sf_complex),pick_compare);
for (i1=ip; i1 < np; i1++) {
pick[i1] = sf_cmplx(crealf(pick[ip-1]),0.);
}
sf_complexwrite(pick,np,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
int function, seislet;
bool verb;
sf_mpi mpipar;
sf_sou soupar;
sf_acqui acpar;
sf_vec_s array;
sf_fwi_s fwipar;
sf_optim optpar=NULL;
sf_seis seispar=NULL;
MPI_Comm comm=MPI_COMM_WORLD;
sf_file Fv, Fw, Fdat, Fimg, Finv=NULL, Ferr=NULL, Fgrad, Fdip=NULL;
MPI_Init(&argc, &argv);
MPI_Comm_rank(comm, &mpipar.cpuid);
MPI_Comm_size(comm, &mpipar.numprocs);
sf_init(argc, argv);
Fv=sf_input("Fvel"); /* velocity model */
Fw=sf_input("Fwavelet"); /* wavelet */
soupar=(sf_sou)sf_alloc(1, sizeof(*soupar));
acpar=(sf_acqui)sf_alloc(1, sizeof(*acpar));
array=(sf_vec_s)sf_alloc(1, sizeof(*array));
/* parameters I/O */
if(!sf_getint("function", &function)) function=2;
/* if 1, forward modeling; if 2, FWI; if 3, RTM */
if(!sf_getint("seislet", &seislet)) seislet=0;
/* if 0, no seislet regularization; if 1, seislet regularization */
if(!sf_histint(Fv, "n1", &acpar->nz)) sf_error("No n1= in Fv");
if(!sf_histint(Fv, "n2", &acpar->nx)) sf_error("No n2= in Fv");
if(!sf_histfloat(Fv, "d1", &acpar->dz)) sf_error("No d1= in Fv");
if(!sf_histfloat(Fv, "d2", &acpar->dx)) sf_error("No d2= in Fv");
if(!sf_histfloat(Fv, "o1", &acpar->z0)) sf_error("No o1= in Fv");
if(!sf_histfloat(Fv, "o2", &acpar->x0)) sf_error("No o2= in Fv");
if(!sf_histint(Fw, "n1", &acpar->nt)) sf_error("No n1= in Fw");
if(!sf_histfloat(Fw, "d1", &acpar->dt)) sf_error("No d1= in Fw");
if(!sf_histfloat(Fw, "o1", &acpar->t0)) sf_error("No o1= in Fw");
if(!sf_getbool("verb", &verb)) verb=false; /* verbosity flag */
if(!sf_getint("nb", &acpar->nb)) acpar->nb=100; /* boundary width */
if(!sf_getfloat("coef", &acpar->coef)) acpar->coef=0.002; /* absorbing boundary coefficient */
if(!sf_getint("acqui_type", &acpar->acqui_type)) acpar->acqui_type=1;
/* if 1, fixed acquisition; if 2, marine acquisition; if 3, symmetric acquisition */
if(!sf_getint("ns", &acpar->ns)) sf_error("shot number required"); /* shot number */
if(!sf_getfloat("ds", &acpar->ds)) sf_error("shot interval required"); /* shot interval */
if(!sf_getfloat("s0", &acpar->s0)) sf_error("shot origin required"); /* shot origin */
if(!sf_getint("sz", &acpar->sz)) acpar->sz=5; /* source depth */
if(!sf_getint("nr", &acpar->nr)) acpar->nr=acpar->nx; /* number of receiver */
if(!sf_getfloat("dr", &acpar->dr)) acpar->dr=acpar->dx; /* receiver interval */
if(!sf_getfloat("r0", &acpar->r0)) acpar->r0=acpar->x0; /* receiver origin */
if(!sf_getint("rz", &acpar->rz)) acpar->rz=5; /* receiver depth */
if(!sf_getint("interval", &acpar->interval)) acpar->interval=1; /* wavefield storing interval */
if(!sf_getfloat("fhi", &soupar->fhi)) soupar->fhi=0.5/acpar->dt; /* high frequency in band, default is Nyquist */
if(!sf_getfloat("flo", &soupar->flo)) soupar->flo=0.; /* low frequency in band, default is zero */
if(!sf_getint("frectx", &soupar->frectx)) soupar->frectx=2; /* source smoothing in x */
if(!sf_getint("frectz", &soupar->frectz)) soupar->frectz=2; /* source smoothing in z */
if(!sf_getint("nsource", &soupar->nsource)) soupar->nsource=1; /* number of sources in a supershot */
if(!sf_getint("dsource", &soupar->dsource)) soupar->dsource=0; /* interval of sources in a supershot */
if(seislet==1){ // seislet regularization
seispar=(sf_seis)sf_alloc(1, sizeof(*seispar));
Fdip=sf_input("Fdip"); /* dip file when seislet=1 */
if(!sf_getfloat("pclip", &seispar->pclip)) seispar->pclip=15; /* soft thresholding parameter */
if(!sf_getint("order", &seispar->order)) seispar->order=1; /* accuracy order of seislet transform */
if(NULL == (seispar->type=sf_getstring("seislet_type"))) seispar->type="linear"; /* [haar, linear, biorthogonal] */
if(!sf_getfloat("eps", &seispar->eps)) seispar->eps=0.1; /* seislet regularization parameter */
seispar->dip=sf_floatalloc2(acpar->nz, acpar->nx);
sf_floatread(seispar->dip[0], acpar->nz*acpar->nx, Fdip);
sf_fileclose(Fdip);
}
/* get prepared */
preparation_s(Fv, Fw, acpar, soupar, array, seispar);
if(function == 1){ // forward modeling
Fdat=sf_output("output"); /* shot data */
/* dimension set up */
sf_putint(Fdat, "n1", acpar->nt);
sf_putfloat(Fdat, "d1", acpar->dt);
sf_putfloat(Fdat, "o1", acpar->t0);
sf_putstring(Fdat, "label1", "Time");
sf_putstring(Fdat, "unit1", "s");
sf_putint(Fdat, "n2", acpar->nr);
sf_putfloat(Fdat, "d2", acpar->dr);
sf_putfloat(Fdat, "o2", acpar->r0);
sf_putstring(Fdat, "label2", "Receiver");
sf_putstring(Fdat, "unit2", "km");
sf_putint(Fdat, "n3", acpar->ns);
sf_putfloat(Fdat, "d3", acpar->ds);
sf_putfloat(Fdat, "o3", acpar->s0);
sf_putstring(Fdat, "label3", "Shot");
sf_putstring(Fdat, "unit3", "km");
forward_modeling(Fdat, &mpipar, soupar, acpar, array, verb);
sf_fileclose(Fdat);
}
else if(function == 2){ // FWI
fwipar=(sf_fwi_s)sf_alloc(1, sizeof(*fwipar));
if(!sf_getbool("onlygrad", &fwipar->onlygrad)) fwipar->onlygrad=false;
/* only calculate gradident or not */
if(!sf_getfloat("wt1", &fwipar->wt1)) fwipar->wt1=acpar->t0; /* window data residual: tmin */
if(!sf_getfloat("wt2", &fwipar->wt2)) fwipar->wt2=acpar->t0+(acpar->nt-1)*acpar->dt; /* window data residual: tmax */
if(!sf_getfloat("woff1", &fwipar->woff1)) fwipar->woff1=acpar->r0; /* window data residual: rmin */
if(!sf_getfloat("woff2", &fwipar->woff2)) fwipar->woff2=acpar->r0+(acpar->nr-1)*acpar->dr; /* window data residual: rmax */
if(!sf_getfloat("gain", &fwipar->gain)) fwipar->gain=1; /* vertical gain power of data residual */
if(!sf_getint("waterz", &fwipar->waterz)) fwipar->waterz=51; /* water layer depth */
if(!sf_getint("grectx", &fwipar->grectx)) fwipar->grectx=3; /* gradient smoothing radius in x */
if(!sf_getint("grectz", &fwipar->grectz)) fwipar->grectz=3; /* gradient smoothing radius in z */
if(!sf_getint("drectx", &fwipar->drectx)) fwipar->drectx=1; /* smoothing kernel radius in x */
if(!sf_getint("drectz", &fwipar->drectz)) fwipar->drectz=1; /* smoothing kernel radius in z */
if(!sf_getint("nrepeat", &fwipar->nrepeat)) fwipar->nrepeat=1; /* smoothing kernel repeat number */
if(!sf_getint("ider", &fwipar->ider)) fwipar->ider=0; /* direction of the derivative */
if(!sf_getfloat("v1", &fwipar->v1)) fwipar->v1=0.; /* lower limit of estimated velocity */
if(!sf_getfloat("v2", &fwipar->v2)) fwipar->v2=10.; /* upper limit of estimated velocity */
Fdat=sf_input("Fdat"); /* input data */
if(!fwipar->onlygrad){
Finv=sf_output("output"); /* FWI result */
Ferr=sf_output("Ferr"); /* data misfit convergence curve */
}
Fgrad=sf_output("Fgrad"); /* FWI gradient at first iteration */
sf_putint(Fgrad, "n1", acpar->nz);
sf_putfloat(Fgrad, "d1", acpar->dz);
sf_putfloat(Fgrad, "o1", acpar->z0);
sf_putstring(Fgrad, "label1", "Depth");
sf_putstring(Fgrad, "unit1", "km");
sf_putint(Fgrad, "n2", acpar->nx);
sf_putfloat(Fgrad, "d2", acpar->dx);
sf_putfloat(Fgrad, "o2", acpar->x0);
sf_putstring(Fgrad, "label2", "Distance");
sf_putstring(Fgrad, "unit2", "km");
if(!fwipar->onlygrad){
optpar=(sf_optim)sf_alloc(1, sizeof(*optpar));
if(!sf_getint("niter", &optpar->niter)) sf_error("iteration number required"); /* iteration number */
if(!sf_getfloat("conv_error", &optpar->conv_error)) sf_error("convergence error required"); /* final convergence error */
if(!sf_getint("npair", &optpar->npair)) optpar->npair=20; /* number of l-BFGS pairs */
if(!sf_getint("nls", &optpar->nls)) optpar->nls=20; /* line search number */
if(!sf_getfloat("factor", &optpar->factor)) optpar->factor=10; /* step length increase factor */
if(!sf_getint("repeat", &optpar->repeat)) optpar->repeat=5; /* after how many iterations the step length goes back to 1 */
if(!sf_getint("err_type", &optpar->err_type)) optpar->err_type=0;
/* if 0, true misfit function; if 1, both smoothing kernel and original L2 norm misfits */
optpar->c1=1e-4;
optpar->c2=0.9;
if(optpar->err_type=0) optpar->nerr=optpar->niter+1;
else optpar->nerr=2*(optpar->niter+1);
optpar->err=sf_floatalloc(optpar->nerr);
}
/* dimension set up */
if(Finv != NULL){
sf_putint(Finv, "n1", acpar->nz);
sf_putfloat(Finv, "d1", acpar->dz);
sf_putfloat(Finv, "o1", acpar->z0);
sf_putstring(Finv, "label1", "Depth");
sf_putstring(Finv, "unit1", "km");
sf_putint(Finv, "n2", acpar->nx);
sf_putfloat(Finv, "d2", acpar->dx);
sf_putfloat(Finv, "o2", acpar->x0);
sf_putstring(Finv, "label2", "Distance");
sf_putstring(Finv, "unit2", "km");
sf_putint(Ferr, "n1", optpar->nerr);
sf_putfloat(Ferr, "d1", 1);
sf_putfloat(Ferr, "o1", 0);
sf_putstring(Ferr, "label1", "Iterations");
sf_putstring(Ferr, "unit1", "");
sf_putint(Ferr, "n2", 1);
sf_putfloat(Ferr, "d2", 1);
sf_putfloat(Ferr, "o2", 0);
}
fwi(Fdat, Finv, Ferr, Fgrad, &mpipar, soupar, acpar, array, fwipar, optpar, verb, seislet);
if(!fwipar->onlygrad){
sf_fileclose(Finv);
sf_fileclose(Ferr);
}
sf_fileclose(Fgrad);
}
else if(function == 3){ // RTM
Fdat=sf_input("Fdat"); /* input data */
Fimg=sf_output("output"); /* rtm image */
/* dimension set up */
sf_putint(Fimg, "n1", acpar->nz);
sf_putfloat(Fimg, "d1", acpar->dz);
sf_putfloat(Fimg, "o1", acpar->z0);
sf_putstring(Fimg, "label1", "Depth");
sf_putstring(Fimg, "unit1", "km");
sf_putint(Fimg, "n2", acpar->nx);
sf_putfloat(Fimg, "d2", acpar->dx);
sf_putfloat(Fimg, "o2", acpar->x0);
sf_putstring(Fimg, "label2", "Distance");
sf_putstring(Fimg, "unit2", "km");
rtm(Fdat, Fimg, &mpipar, soupar, acpar, array, verb);
sf_fileclose(Fimg);
}
MPI_Finalize();
exit(0);
}
