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); }