void warp3_init(int n1_in, float o1, float d1,
int n2_in, float o2, float d2,
int n3_in, float o3, float d3 /* output grid */,
int nt, int ny_in, int nx_in /* input grid */,
float eps /* regularization */)
/*< initialize >*/
{
n1 = n1_in;
n2 = n2_in;
n3 = n3_in;
ny = ny_in;
nx = nx_in;
map1 = stretch4_init (n1, o1, d1, nt, eps);
trace1 = sf_floatalloc(n1);
trace2 = sf_floatalloc2(n2,n3);
warp2_init(n2,o2,d2,
n3,o3,d3,
ny,nx,eps);
str2 = sf_floatalloc3(ny,nx,n1);
str3 = sf_floatalloc3(ny,nx,n1);
slice1 = sf_floatalloc3(ny,nx,n1);
}
int main (int argc, char *argv[])
{
int m, k, l, seed;
sf_file bshuffle,ashuffle;
sf_axis ax,at,ap,av;
int nx,nt,np,nv,iteration,*a1, *a2;
float ***bsh, ***bsh2;
sf_init(argc,argv);
bshuffle=sf_input("in");
ashuffle=sf_output("out");
if (!sf_getint("iteration",&iteration)) iteration=1;
if (!sf_getint("seed",&seed)) seed=2012;
at=sf_iaxa( bshuffle,1); nt=sf_n(at);
ax=sf_iaxa( bshuffle,3); nx=sf_n(ax);
ap=sf_iaxa( bshuffle,2); np=sf_n(ap);
av=sf_iaxa( bshuffle,4); nv=sf_n(av);
bsh=sf_floatalloc3(nt,np,nx);
bsh2=sf_floatalloc3(nt,np,nx);
a1=sf_intalloc(np);
a2=sf_intalloc(np);
sf_warning("ntpx=%d",nt*np*nx);
srand(seed);
for (m=0; m<np; m++) {
a1[m]=rand();
}
bubble(a1, a2, np);
for (k=0; k<nv; k++) {
sf_floatread(bsh[0][0],nt*np*nx,bshuffle);
for(l=0; l<nx; l++) {
for (m=0; m<np; m++) {
memcpy(bsh2[l][m], bsh[l][a2[m]], nt*sizeof(float));
}
}
sf_floatwrite(bsh2[0][0],nt*np*nx,ashuffle);
}
free(bsh[0][0]);
free(bsh[0]);
free(bsh);
free(bsh2[0][0]);
free(bsh2[0]);
free(bsh2);
free(a1);
free(a2);
exit (0);
}
void coh1_init(int win, int m1, int m2, int l1, int l2)
/*< initialize >*/
{
nw = win;
n1 = m1;
n2 = m2;
lag1 = l1;
lag2 = l2;
u0 = sf_floatalloc3(2*nw+1, n1, n2);
u1 = sf_floatalloc3(2*nw+1, n1, n2);
v = sf_floatalloc2(2*(l1>l2? l1:l2)+1, n2);
/* use two d memory for OPENMP */
}
int main(int argc, char* argv[])
{
int wide1,wide2,wide3, wide, shift1, shift2, shift3, i, j, k, i1, n1, i2, n2, i3, n3, i4, n4;
float ***data, ***signal, ***win;
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");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&n3)) sf_error("No n3= in input");
n4 = sf_leftsize(in,3);
data = sf_floatalloc3(n1,n2,n3);
signal = sf_floatalloc3(n1,n2,n3);
if (!sf_getint("wide1",&wide1)) wide1=5;
if (!sf_getint("wide2",&wide2)) wide2=5;
if (!sf_getint("wide3",&wide3)) wide3=5;
/* sliding window width */
wide = wide1*wide2*wide3;
win = sf_floatalloc3(wide1,wide2,wide3);
for (i4=0; i4 < n4; i4++) {
sf_floatread(data[0][0],n1*n2*n3,in);
for (i3=0; i3 < n3; i3++) { shift3 = SF_MAX (0, SF_MIN (n3-wide3, i3-wide3/2));
for (i2=0; i2 < n2; i2++) { shift2 = SF_MAX (0, SF_MIN (n2-wide2, i2-wide2/2));
for (i1=0; i1 < n1; i1++) { shift1 = SF_MAX (0, SF_MIN (n1-wide1, i1-wide1/2));
for (i=0; i < wide; i++) {
for (j=0; j < wide; j++) {
for (k=0; k < wide; k++) {
win[i][j][k] = data[shift3+k][shift2+i][shift1+j];
}
}
}
signal[i3][i2][i1] = sf_quantile(wide/2,wide,win[0][0]);
}
}
}
sf_floatwrite(signal[0][0],n1*n2*n3,out);
}
exit(0);
}
grid2 grid2_init (int n1, float o1, float d1 /* first axis */,
int n2, float o2, float d2 /* second axis */,
float *slow2 /* data values [n1*n2] */,
int order /* interpolation order */)
/*< Initialize grid object >*/
{
int i, j;
float v, vgrad[2];
grid2 grd;
grd = (grid2) sf_alloc(1,sizeof(*grd));
grd->n1 = n1; grd->o1 = o1; grd->d1 = d1;
grd->n2 = n2; grd->o2 = o2; grd->d2 = d2;
grd->pnt = sf_eno2_init (order != 0 ? order : 3, n1, n2);
sf_eno2_set1 (grd->pnt, slow2);
grd->vel = NULL;
if (order <= 0) {
grd->vel = sf_floatalloc3 (3, n1, n2);
for (j = 0; j < n2; j++) {
for (i = 0; i < n1; i++) {
sf_eno2_apply (grd->pnt, i, j, 0., 0., &v, vgrad, BOTH);
grd->vel[j][i][0] = slow2[j*n1 + i];
grd->vel[j][i][1] = 0.5*vgrad[0]/d1;
grd->vel[j][i][2] = 0.5*vgrad[1]/d2;
}
}
sf_eno2_close (grd->pnt);
}
return grd;
}
void rgradient_init(char* type, int horder, int m1, int m2)
/*< initialize >*/
{
float **p;
int i;
order = horder;
nf = 2*order+1;
c = sf_floatalloc2(nf, 2);
p = lphpoly(order, order, type);
for(i=0; i<2*nf; i++) c[0][i] = p[0][i];
free(p[0]);
free(p);
mode = type[0];
n1 = m1;
n2 = m2;
b1 = sf_floatalloc2(n1, n2);
b2 = sf_floatalloc2(n1, n2);
g = sf_floatalloc3(n1*3, n2, nf);
b = g[0];
memset(g[0][0], 0, n1*n2*nf*sizeof(float));
#ifdef _OPENMP
omp_init();
#endif
}
void* fcoh2_init(int n1, int n2, int pmin, int pmax, int nw)
/*< initialize >*/
{
fcoh2 *p;
p = sf_alloc(1,sizeof(fcoh2));
p->n1 = n1;
p->n2 = n2;
p->min = pmin;
p->max = pmax;
p->ntw = nw;
p->d1 = sf_floatalloc3(n1, n2, pmax-pmin+1);
p->d2 = sf_floatalloc3(n1, n2, pmax-pmin+1);
return p;
}
/*------------------------------------------------------------*/
slo3d slow3_init(cub3d cub,
sf_fslice slice_, /* slowness slice */
int nrmax, /* maximum number of references */
float dsmax,
float twoway
)
/*< initialize slowness >*/
{
int imz, jj;
int ompith=0;
/*------------------------------------------------------------*/
slo3d slo;
slo = (slo3d) sf_alloc(1,sizeof(*slo));
slo->slice=slice_;
slo->nrmax=nrmax;
slo->dsmax=dsmax;
if(twoway) { slo->twoway = 2;
} else { slo->twoway = 1;
}
slo->ss = sf_floatalloc3(cub->alx.n,cub->aly.n,cub->ompnth); /* slowness */
slo->so = sf_floatalloc3(cub->alx.n,cub->aly.n,cub->ompnth); /* slowness */
slo->sm = sf_floatalloc2(slo->nrmax,cub->amz.n); /* ref slowness squared */
slo->nr = sf_intalloc (cub->amz.n); /* nr of ref slownesses */
for (imz=0; imz<cub->amz.n; imz++) {
sf_fslice_get(slo->slice,imz,slo->ss[0][0]);
slow3_twoway(cub,slo,slo->ss,ompith);
slo->nr[imz] = slow3(slo->nrmax,
slo->dsmax,
cub->alx.n*cub->aly.n,
slo->ss[0][0],
slo->sm[imz]);
}
for (imz=0; imz<cub->amz.n-1; imz++) {
for (jj=0; jj<slo->nr[imz]; jj++) {
slo->sm[imz][jj] = 0.5*(slo->sm[imz][jj]+slo->sm[imz+1][jj]);
}
}
return slo;
}
void resample_vel(const modeling_t *olds, const modeling_t *news, const vel_t *oldv, vel_t *newv) {
free(**newv->dat); free(*newv->dat); free(newv->dat);
free(**newv->vgamma); free(*newv->vgamma); free(newv->vgamma);
newv->dat = sf_floatalloc3(news->n1, news->n2, news->n3);
newv->vgamma = sf_floatalloc3(news->n1, news->n2, news->n3);
interpfield(olds, news, oldv->dat, newv->dat, true);
for (int i3 = 0; i3 < news->n3; i3++) {
for (int i2 = 0; i2 < news->n2; i2++) {
for (int i1 = 0; i1 < news->n1; i1++) {
newv->vgamma[i3][i2][i1] = -powf(newv->dat[i3][i2][i1],2*gs_gamma-1) * powf(gs_w0, 2 * gs_gamma) * sin(SF_PI * gs_gamma) / news->dt;
}
}
}
}
void resample_p(const modeling_t *olds, const modeling_t *news, float ****p)
{
float ***newp = sf_floatalloc3(news->n1, news->n2, news->n3);
interpfield(olds, news, *p, newp, false);
free((*p)[0][0]); free((*p)[0]); free(*p);
*p = newp;
}
int main(int argc, char* argv[])
{
int n1, n2,o1,d1,d2,i1,i2,ix,iz;
float ***dat,**sum;
float sum1;
sf_file in, out; /* Input and output files */
/* Initialize RSF */
sf_init(argc,argv);
/* standard input */
in = sf_input("in");
/* standard output */
out = sf_output("out");
/* parameters from input file*/
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if (!sf_histint(in,"o1",&o1)) sf_error("No o1= in input");
if (!sf_histint(in,"d1",&d1)) sf_error("No d1= in input");
if (!sf_histint(in,"d2",&d2)) sf_error("No d2= in input");
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_histint(in,"n3",&n3)) sf_error("No n3= in input");
fprintf(stderr,"values: %d %d\n",n1,n2,n3);
sum = sf_floatalloc2(n3,n3);
dat = sf_floatalloc3 (n1,n2,n3);
fprintf(stderr,"values: %d %d\n",n1,n2);
dat = sf_floatalloc2 (n1,n2);
for (ix=0; ix<n2; ++ix) {
for (iz=0; iz<n1; ++iz) {
dat[ix][iz]=0.0;
}
}
sum1=0;
fprintf(stderr,"values1: %f\n",sum1);
sf_floatread(dat[0],n1*n2,in);
//sum1=0;
fprintf(stderr,"values1: %f\n",sum1);
for (i2=o1; i2<n2; ++i2){
for (i1=o1; i1<n1; ++i1){
sum1 += dat[i2][i1];
}
}
fprintf(stderr,"values: %f\n",sum1);
sum[0][0]=sum1;
sf_floatwrite(sum[0],1*1,out);
exit(0);
}
vel_t *clone_vel(float ***vel, int nz, int nx, int ny,
float oz, float ox, float oy,
float dz, float dx, float dy,
float w0, float qfact)
{
vel_t *v = malloc(sizeof *v);
v->n1 = nz; v->n2 = nx; v->n3 = ny;
v->o1 = oz; v->o2 = ox; v->o3 = oy;
v->d1 = dz; v->d2 = dx; v->d3 = dy;
v->dat = sf_floatalloc3(nz, nx, ny);
memcpy(v->dat[0][0], vel[0][0], nz*nx*ny*sizeof(float));
v->vgamma = sf_floatalloc3(1,1,1);
gs_w0 = w0; gs_qfact= qfact;
gs_gamma = 1.0/SF_PI*atan(2*SF_PI/qfact);
sf_warning("gs_gamma: %f", gs_gamma);
return v;
}
/*------------------------------------------------------------*/
wexop3d wex_init(wexcub3d cub)
/*< initialize >*/
{
wexop3d weop;
weop = (wexop3d) sf_alloc(1,sizeof(*weop));
weop->wws = sf_complexalloc3(cub->amx.n,cub->amy.n,cub->ompnth);
weop->wwr = sf_complexalloc3(cub->amx.n,cub->amy.n,cub->ompnth);
weop->ws = sf_complexalloc4(cub->amx.n,cub->amy.n,cub->az.n,cub->ompnth);
weop->wr = sf_complexalloc4(cub->amx.n,cub->amy.n,cub->az.n,cub->ompnth);
weop->rr = sf_floatalloc3(cub->amx.n,cub->amy.n,cub->az.n);
return weop;
}
/*------------------------------------------------------------*/
void fdbell3d_init(int n)
/*< init bell taper >*/
{
int i1,i2,i3;
float s;
nbell = n;
s = 0.5*nbell;
bell3d=sf_floatalloc3(2*nbell+1,2*nbell+1,2*nbell+1);
for (i3=-nbell;i3<=nbell;i3++) {
for (i2=-nbell;i2<=nbell;i2++) {
for(i1=-nbell;i1<=nbell;i1++) {
bell3d[nbell+i3][nbell+i2][nbell+i1] = exp(-(i1*i1+i2*i2+i3*i3)/s);
}
}
}
}
/*------------------------------------------------------------*/
void fdbell3d_init(int n)
/*< init bell taper >*/
{
int iz,ix,i3;
float s;
nbell = n;
s = 0.5*nbell;
bell3d=sf_floatalloc3(2*nbell+1,2*nbell+1,2*nbell+1);
for (i3=-nbell;i3<=nbell;i3++) {
for (ix=-nbell;ix<=nbell;ix++) {
for(iz=-nbell;iz<=nbell;iz++) {
bell3d[nbell+i3][nbell+ix][nbell+iz] = exp(-(iz*iz+ix*ix+i3*i3)/s);
}
}
}
}
void weimc_init(bool verb_,
axa amx_ /* i-line (data) */,
axa amy_ /* x-line (data) */,
axa amz_ /* depth */,
axa aw_ /* frequency */
)
/*< initialize WE IC >*/
{
verb=verb_;
amz = amz_;
amx = amx_;
amy = amy_;
aw = aw_;
/* allocate wavefield storage */
us = sf_complexalloc3(amx.n,amy.n,amz.n);
ur = sf_complexalloc3(amx.n,amy.n,amz.n);
qq = sf_floatalloc3 (amx.n,amy.n,amz.n);
}
void phasescan_init(int m1 /* input trace length */,
float o11 /* input origin */,
float d11 /* float increment */,
int m2 /* output trace length */,
float o21 /* output origin */,
float d21 /* output increment */,
int na1 /* number of scanned angle */,
float a01 /* first angle*/,
float da1 /* angle increment */,
int ntr1 /* number of traces */,
int order1 /* interpolation accuracy */,
int dim /* dimensionality */,
int *m /* data dimensions [dim] */,
int *rect /* smoothing radius [dim] */,
int niter /* number of iterations */,
bool verb /* verbosity */)
/*< initialize >*/
{
n1 = m1;
o1 = o11;
d1 = d11;
o2 = o21;
d2 = d21;
n2 = m2;
ntr = ntr1;
na = na1; /*angle number*/
angle0 = a01; /*first angle*/
dangle = da1;/* angle increment*/
n2g = n2*na*ntr;
order = order1;
coord = sf_floatalloc (n2);
out = sf_floatalloc3 (n2,na,ntr);
rat2 = sf_floatalloc (n2g);
num = sf_floatalloc (n2g);
den = sf_floatalloc (n2g);
spl = sf_spline_init (order, n1);
sf_divn_init(dim, n2g, m, rect, niter, verb);
}
vel_t *read_vel(const char *tag)
{
sf_file fvel = sf_input(tag);
sf_seek(fvel, 0, SEEK_SET);
vel_t *v = malloc(sizeof *v);
sf_histint(fvel, "n1", &v->n1);
sf_histint(fvel, "n2", &v->n2);
sf_histint(fvel, "n3", &v->n3);
sf_histfloat(fvel, "o1", &v->o1);
sf_histfloat(fvel, "o2", &v->o2);
sf_histfloat(fvel, "o3", &v->o3);
sf_histfloat(fvel, "d1", &v->d1);
sf_histfloat(fvel, "d2", &v->d2);
sf_histfloat(fvel, "d3", &v->d3);
v->dat = sf_floatalloc3(v->n1, v->n2, v->n3);
sf_floatread(v->dat[0][0], v->n1 * v->n2 * v->n3, fvel);
return v;
}
void pt2dread2(sf_file F,
pt2d **v,
size_t n1,
size_t n2,
int k)
/*< input point2d 2-D vector >*/
{
int i1,i2;
float ***w;
w=sf_floatalloc3(k,n1,n2);
sf_floatread(w[0][0],k*n1*n2,F);
for( i2=0; i2<(int)n2; i2++) {
for( i1=0; i1<(int)n1; i1++) {
; v[i2][i1].x = w[i2][i1][0];
; v[i2][i1].z = w[i2][i1][1];
if(k==3) v[i2][i1].v = w[i2][i1][2];
}
}
free(**w); free(*w); free(w);
}
void pt2dwrite2(sf_file F,
pt2d **v,
size_t n1,
size_t n2,
int k)
/*< output point2d 2-D vector >*/
{
int i1,i2;
float ***w;
w=sf_floatalloc3(k,n1,n2);
for( i2=0; i2<(int)n2; i2++) {
for( i1=0; i1<(int)n1; i1++) {
; w[i2][i1][0] = v[i2][i1].x;
; w[i2][i1][1] = v[i2][i1].z;
if(k==3) w[i2][i1][2] = v[i2][i1].v;
}
}
sf_floatwrite(w[0][0],k*n1*n2,F);
free(**w); free(*w); free(w);
}
int main (int argc, char *argv[])
{
bool verb;
int n1,n2,n3, n12, n23, ref2, ref3, i2,i3,i1, ud, lr, order;
float eps, ***dat, ***p, ***q, **p2, **q2, *trace;
sf_file dip, out, seed, cost;
sf_init(argc,argv);
dip = sf_input("in");
out = sf_output("out");
seed = sf_input("seed");
cost = sf_input("cost");
if (!sf_histint(dip,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(dip,"n2",&n2)) sf_error("No n2= in input");
if (!sf_histint(dip,"n3",&n3)) sf_error("No n3= in input");
n23 = n2*n3;
n12 = n1*n23;
if (!sf_getbool("verb",&verb)) verb=false;
if (!sf_getfloat("eps",&eps)) eps=0.01;
/* regularization */
if (!sf_getint("ref2",&ref2)) ref2=0;
if (!sf_getint("ref3",&ref3)) ref3=0;
/* reference trace */
sf_putint(out,"n4",1);
p = sf_floatalloc3(n1,n2,n3);
q = sf_floatalloc3(n1,n2,n3);
dat = sf_floatalloc3(n1,n2,n3);
sf_floatread(p[0][0],n12,dip);
sf_floatread(q[0][0],n12,dip);
p2 = sf_floatalloc2(n2,n3);
q2 = sf_floatalloc2(n2,n3);
sf_floatread(p2[0],n23,cost);
sf_floatread(q2[0],n23,cost);
dijkstra_init(n2,n3,p2,q2);
dijkstra_source(ref2,ref3);
sf_floatread(dat[ref3][ref2],n1,seed);
if (verb) sf_warning("%d %d",ref2,ref3);
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
predict_init(n1,n2, eps*eps, order, 1, false);
while (dijskstra_step(&i2,&i3,&ud,&lr)) {
if (verb) sf_warning("%d %d",i2,i3);
trace = dat[i3][i2];
for (i1=0; i1 < n1; i1++) {
trace[i1] = dat[i3-lr][i2-ud][i1];
}
if (ud > 0) {
predict_step(false,true,trace,p[i3][i2-ud]);
} else if (ud < 0) {
predict_step(false,false,trace,p[i3][i2]);
}
if (lr > 0) {
predict_step(false,true,trace,q[i3-lr][i2]);
} else if (lr < 0) {
predict_step(false,false,trace,q[i3][i2]);
}
}
sf_floatwrite(dat[0][0],n12,out);
exit (0);
}
int main(int argc, char* argv[])
{
int nx, nz, nt, ix, iz, it, nbt, nbb, nxl, nxr, nxb, nyb, nzb, isx, isz;
float dt, dx, dy, dz, o1, o2, o3;
float **old, **cur, **tmp, *wav;
float **v, **vtmp, v0, **sigma, **delta, **seta;
float ***aa, w, g1, g2, czt, czb, cxl, cxr; /* top, bottom, left, right */
float ax, az, factor;
sf_file out, vel, source, fsigma, fdelta, fseta;
int opt, snap, nsnap; /* optimal padding */
sf_init(argc,argv);
out = sf_output("out");
vel = sf_input("vel"); /* velocity */
fsigma = sf_input("sigma"); /* velocity */
fdelta = sf_input("delta"); /* velocity */
fseta = sf_input("seta"); /* velocity */
source = sf_input("in"); /* source wavlet*/
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_histfloat(vel,"o1",&o1)) o1=0.0;
if (!sf_histfloat(vel,"o2",&o2)) o2=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("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;
/* assume ABC pars are the same */
if (nbt != nbb || nxl != nxr || nbt!=nxl)
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_getint("snap",&snap)) snap=1;
nsnap=0;
for (it=0; it < nt; it++) {
if (it%snap == 0) nsnap++;
}
sf_putfloat(out,"d1",dz);
sf_putfloat(out,"d2",dx);
sf_putfloat(out,"d3",dt*snap);
sf_putfloat(out,"o1",o1);
sf_putfloat(out,"o2",o2);
sf_putfloat(out,"o3",0.0);
nxb = nx + nxl + nxr;
nzb = nz + nbt + nbb;
sf_putint(out,"n1",nzb);
sf_putint(out,"n2",nxb);
sf_putint(out,"n3",nsnap);
wav = sf_floatalloc(nt);
sf_floatread(wav,nt,source);
old = sf_floatalloc2(nzb,nxb);
cur = sf_floatalloc2(nzb,nxb);
aa = sf_floatalloc3(nzb,nxb,3);
bd2_init(nx,nz,nxl,nxr,nbt,nbb,cxl,cxr,czt,czb);
/*input & extend velocity model*/
v = sf_floatalloc2(nzb,nxb);
vtmp = sf_floatalloc2(nz,nx);
sf_floatread(vtmp[0],nx*nz,vel);
v = extmodel(vtmp, nz, nx, nbt);
sigma = sf_floatalloc2(nzb,nxb);
sf_floatread(vtmp[0],nx*nz,fsigma);
sigma = extmodel(vtmp, nz, nx, nbt);
delta = sf_floatalloc2(nzb,nxb);
sf_floatread(vtmp[0],nx*nz,fdelta);
delta = extmodel(vtmp, nz, nx, nbt);
seta = sf_floatalloc2(nzb,nxb);
sf_floatread(vtmp[0],nx*nz,fseta);
seta = extmodel(vtmp, nz, nx, nbt);
v0 =0.0;
for (ix=0; ix < nxb; ix++) {
for (iz=0; iz < nzb; iz++) {
v0 += v[ix][iz]*v[ix][iz];
}
}
v0 = sqrtf(v0/(nxb*nzb));
fprintf(stderr, "v0=%f\n\n", v0);
for (ix=0; ix < nxb; ix++) {
for (iz=0; iz < nzb; iz++) {
cur[ix][iz] = 0.0;
old[ix][iz] = 0.0;
}
}
/* propagation in time */
pamstep2_init(nzb,nxb,dz,dx,opt);
for (it=0; it < nt; it++) {
fprintf(stderr, "\b\b\b\b\b%d", it);
pamstep2(old, cur, nzb, nxb, dz, dx, v0, v, sigma, delta, seta, dt);
old[isx+nxl][isz+nbt] += wav[it];
bd2_decay(old);
bd2_decay(cur);
tmp = old;
old = cur;
cur = tmp;
if (it%nsnap==0)
sf_floatwrite(cur[0], nxb*nzb, out);
}
pamstep2_close();
bd2_close();
free(**aa);
free(*aa);
free(aa);
free(*v);
free(*sigma);
free(*delta);
free(*seta);
free(*vtmp);
free(*cur);
free(*old);
free(v);
free(sigma);
free(delta);
free(seta);
free(vtmp);
free(cur);
free(old);
exit(0);
}
int
main(int argc, char** argv)
{
bool verb, fsrf, snap, expl, dabc, cden, adj;
bool optfd, hybrid, sinc;
int jsnap, jdata;
/* I/O files */
sf_file file_wav=NULL; /* wavelet */
sf_file file_vel=NULL; /* velocity */
sf_file file_den=NULL; /* density */
sf_file file_wfl=NULL; /* wavefield */
sf_file file_dat=NULL; /* data */
sf_file file_src=NULL; /* sources */
sf_file file_rec=NULL; /* receivers */
/* cube axes */
sf_axis at = NULL, az = NULL, ax = NULL, ay = NULL;
sf_axis as = NULL, ar = NULL;
int nbd; /* ABC boundary size */
int fdorder; /* finite difference spatial accuracy order */
int nzpad,nxpad,nypad; /* boundary padded model size */
int ix,iy,it,is,nx,ny,nz,nt,ns,nr;
float dx,dy,dz,dt,dt2;
float* damp=NULL; /* damping profile for hybrid bc */
float* ws; /* wavelet */
float*** vel=NULL; /* velocity */
float*** rho=NULL; /* density */
float*** u0=NULL; /* wavefield array u@t-1 (u@t+1) */
float*** u1=NULL; /* wavefield array u@t */
float* u_dat=NULL; /* output data */
float*** ptr_tmp=NULL;
pt3d* src3d=NULL; /* source position */
pt3d* rec3d=NULL; /*receiver position*/
scoef3d cssinc = NULL, crsinc = NULL;
lint3d cslint = NULL, crlint = NULL;
/* FDM structure */
fdm3d fdm = NULL;
abcone3d abc = NULL;
sponge spo = NULL;
int nbell;
float* fdcoef_d2;
float* fdcoef_d1;
sf_axis acz = NULL, acx = NULL, acy = NULL;
int nqz, nqx, nqy;
float oqz, oqx, oqy, dqz, dqx, dqy;
float** oslice = NULL; /* output 3D wavefield slice-by-slice */
float*** tmp_array;
double wall_clock_time_s, wall_clock_time_e;
const int SECOND_DERIV = 2;
const int FIRST_DERIV = 1;
int nop;
#if defined _OPENMP && _DEBUG
double tic;
double toc;
#endif
/* init RSF */
sf_init(argc,argv);
#ifdef _OPENMP
omp_init();
wall_clock_time_s = omp_get_wtime();
#else
wall_clock_time_s = (double) clock() / CLOCKS_PER_SEC;
#endif
if (!sf_getbool("verb",&verb)) verb=false; /* Verbosity flag */
if (!sf_getbool("snap",&snap)) snap=false; /* Wavefield snapshots flag */
if (!sf_getbool("expl",&expl)) expl=false; /* Multiple sources, one wvlt*/
if (!sf_getbool("dabc",&dabc)) dabc=false; /* Absorbing BC */
if (!sf_getbool("cden",&cden)) cden=false; /* Constant density */
if (!sf_getbool("adj",&adj)) adj=false; /* adjoint flag */
if (!sf_getbool("free",&fsrf) && !sf_getbool("fsrf",&fsrf)) fsrf=false; /* Free surface flag */
if (!sf_getint("nbell",&nbell)) nbell=5; /* gaussian for source injection */
if (!sf_getbool("optfd",&optfd)) optfd=false; /* optimized FD coefficients flag */
if (!sf_getint("fdorder",&fdorder)) fdorder=4; /* spatial FD order */
if (!sf_getbool("hybridbc",&hybrid)) hybrid=false; /* hybrid Absorbing BC */
if (!sf_getbool("sinc",&sinc)) sinc=false; /* sinc source injection */
/* Initialize variables */
file_wav = sf_input("in"); /* wavelet */
file_vel = sf_input("vel"); /* velocity */
file_src = sf_input("sou"); /* sources */
file_rec = sf_input("rec"); /* receivers */
file_dat = sf_output("out"); /* data */
if (snap) file_wfl = sf_output("wfl"); /* wavefield */
if (!cden) {
if (sf_getstring("cden")) {
file_den = sf_input ("den"); /* density */
} else {
cden = true;
if (verb) sf_warning("No density file provided, running with constant density");
}
}
at = sf_iaxa(file_wav,2); sf_setlabel(at,"t"); if(verb) sf_raxa(at); /* time */
az = sf_iaxa(file_vel,1); sf_setlabel(az,"z"); if(verb) sf_raxa(az); /* depth */
ax = sf_iaxa(file_vel,2); sf_setlabel(ax,"x"); if(verb) sf_raxa(ax); /* space */
ay = sf_iaxa(file_vel,3); sf_setlabel(ay,"y"); if(verb) sf_raxa(ay); /* space */
as = sf_iaxa(file_src,2); sf_setlabel(as,"s"); if(verb) sf_raxa(as); /* sources */
ar = sf_iaxa(file_rec,2); sf_setlabel(ar,"r"); if(verb) sf_raxa(ar); /* receivers */
nt = sf_n(at); dt = sf_d(at);
nz = sf_n(az); dz = sf_d(az);
nx = sf_n(ax); dx = sf_d(ax);
ny = sf_n(ay); dy = sf_d(ay);
ns = sf_n(as);
nr = sf_n(ar);
/* other execution parameters */
if (snap) {
if (!sf_getint("jsnap",&jsnap)) jsnap=nt;
/* # of t steps at which to save wavefield */
}
if (!sf_getint("jdata",&jdata)) jdata=1;
/* # of t steps at which to save receiver data */
/* setup output data header */
sf_oaxa(file_dat,ar,1);
sf_setn(at,(nt-1)/jdata+1);
sf_setd(at,dt*jdata);
sf_oaxa(file_dat,at,2);
/* wavefield cut params */
/* setup output wavefield header */
if (snap) {
if (!sf_getint ("nqz",&nqz)) nqz=sf_n(az); /* Saved wfld window nz */
if (!sf_getint ("nqx",&nqx)) nqx=sf_n(ax); /* Saved wfld window nx */
if (!sf_getint ("nqy",&nqy)) nqy=sf_n(ay); /* Saved wfld window ny */
if (!sf_getfloat("oqz",&oqz)) oqz=sf_o(az); /* Saved wfld window oz */
if (!sf_getfloat("oqx",&oqx)) oqx=sf_o(ax); /* Saved wfld window ox */
if (!sf_getfloat("oqy",&oqy)) oqy=sf_o(ay); /* Saved wfld window oy */
if (!sf_getfloat("dqz",&dqz)) dqz=sf_d(az); /* Saved wfld window dz */
if (!sf_getfloat("dqx",&dqx)) dqx=sf_d(ax); /* Saved wfld window dx */
if (!sf_getfloat("dqy",&dqy)) dqy=sf_d(ay); /* Saved wfld window dy */
acz = sf_maxa(nqz,oqz,dqz); if (verb) sf_raxa(acz);
acx = sf_maxa(nqx,oqx,dqx); if (verb) sf_raxa(acx);
acy = sf_maxa(nqy,oqy,dqy); if (verb) sf_raxa(acy);
/* check if the imaging window fits in the wavefield domain */
sf_setn(at,(nt-1)/jsnap+1);
sf_setd(at,dt*jsnap);
if (verb) sf_raxa(at);
sf_oaxa(file_wfl,acz,1);
sf_oaxa(file_wfl,acx,2);
sf_oaxa(file_wfl,acy,3);
sf_oaxa(file_wfl,at,4);
}
/* 2-2N finite difference coefficient */
nop = fdorder/2; /* fd half-length stencil */
if (!sf_getint("nb",&nbd) || nbd<nop) nbd=nop;
if (dabc && hybrid && nbd<=nop) nbd = 2*nop;
/* expand domain for FD operators and ABC */
fdm = fdutil3d_init(verb,fsrf,az,ax,ay,nbd,1);
sf_setn(az,fdm->nzpad); sf_seto(az,fdm->ozpad); if (verb) sf_raxa(az);
sf_setn(ax,fdm->nxpad); sf_seto(ax,fdm->oxpad); if (verb) sf_raxa(ax);
sf_setn(ay,fdm->nypad); sf_seto(ay,fdm->oypad); if (verb) sf_raxa(ay);
/* Precompute coefficients */
dt2 = dt*dt;
nzpad = nz+2*nbd; nxpad = nx+2*nbd; nypad = ny+2*nbd;
fdcoef_d2 = compute_fdcoef(nop,dz,dx,dy,optfd,SECOND_DERIV);
fdcoef_d1 = compute_fdcoef(nop,dz,dx,dy,optfd,FIRST_DERIV);
/* Allocate memories */
if (expl) ws = sf_floatalloc(1);
else ws = sf_floatalloc(ns);
vel = sf_floatalloc3(nzpad,nxpad,nypad);
if (!cden) rho = sf_floatalloc3(nzpad,nxpad,nypad);
u_dat = sf_floatalloc(nr);
src3d = pt3dalloc1(ns);
rec3d = pt3dalloc1(nr);
if (snap) oslice = sf_floatalloc2(sf_n(acz),sf_n(acx));
/* source and receiver position */
pt3dread1(file_src,src3d,ns,3); /* read format: (x,y,z) */
if (sinc) cssinc = sinc3d_make(ns,src3d,fdm);
else cslint = lint3d_make(ns,src3d,fdm);
pt3dread1(file_rec,rec3d,nr,3); /* read format: (x,y,z) */
if (sinc) crsinc = sinc3d_make(nr,rec3d,fdm);
else crlint = lint3d_make(nr,rec3d,fdm);
if (!sinc) fdbell3d_init(nbell);
/* temperary array */
tmp_array = sf_floatalloc3(nz,nx,ny);
/* read velocity and pad */
sf_floatread(tmp_array[0][0],nz*nx*ny,file_vel);
expand3d(tmp_array,vel,fdm);
/* read density and pad */
if (!cden) {
sf_floatread(tmp_array[0][0],nz*nx*ny,file_den);
expand3d(tmp_array,rho,fdm);
}
free(**tmp_array); free(*tmp_array); free(tmp_array);
/* A1 one-way ABC implicit scheme coefficients */
if (dabc) {
abc = abcone3d_make(nbd,dt,vel,fsrf,fdm);
if (hybrid)
damp = damp_make(nbd-nop); /* compute damping profiles for hybrid bc */
else
spo = sponge_make(fdm->nb);
}
/* allocate memory for wavefield variables */
u0 = sf_floatalloc3(nzpad,nxpad,nypad);
u1 = sf_floatalloc3(nzpad,nxpad,nypad);
/* initialize variables */
memset(u0[0][0],0,sizeof(float)*nzpad*nxpad*nypad);
memset(u1[0][0],0,sizeof(float)*nzpad*nxpad*nypad);
memset(u_dat,0,sizeof(float)*nr);
/* v = (v*dt)^2 */
for (ix=0;ix<nzpad*nxpad*nypad;ix++)
*(vel[0][0]+ix) *= *(vel[0][0]+ix)*dt2;
if (fsrf && !hybrid) {
for (iy=0; iy<nypad; iy++)
for (ix=0; ix<nxpad; ix++)
memset(vel[iy][ix],0,sizeof(float)*fdm->nb);
}
for (it=0; it<nt; it++) {
if (verb) sf_warning("it=%d;",it+1);
#if defined _OPENMP && _DEBUG
tic=omp_get_wtime();
#endif
step_forward(u0,u1,vel,rho,fdcoef_d2,fdcoef_d1,nop,nzpad,nxpad,nypad);
if (adj) { /* backward inject source wavelet */
if (expl) {
sf_seek(file_wav,(off_t)(nt-it-1)*sizeof(float),SEEK_SET);
sf_floatread(ws,1,file_wav);
ws[0] *= dt2;
if (sinc) sinc3d_inject1(u0,ws[0],cssinc);
else lint3d_inject1(u0,ws[0],cslint);
} else {
sf_seek(file_wav,(off_t)(nt-it-1)*ns*sizeof(float),SEEK_SET);
sf_floatread(ws,ns,file_wav);
for (is=0; is<ns; is++) ws[is] *= dt2;
if (sinc) sinc3d_inject(u0,ws,cssinc);
else lint3d_inject(u0,ws,cslint);
}
} else { /* forward inject source wavelet */
if (expl) {
sf_floatread(ws,1,file_wav);
ws[0] *= dt2;
if (sinc) sinc3d_inject1(u0,ws[0],cssinc);
else lint3d_inject1(u0,ws[0],cslint);
} else {
sf_floatread(ws,ns,file_wav);
for (is=0; is<ns; is++) ws[is] *= dt2;
if (sinc) sinc3d_inject(u0,ws,cssinc);
else lint3d_inject(u0,ws,cslint);
}
}
/* apply abc */
if (dabc) {
if (hybrid) apply_abc(u0,u1,nz,nx,ny,nbd,abc,nop,damp);
else {
abcone3d_apply(u0,u1,nop,abc,fdm);
sponge3d_apply(u0,spo,fdm);
sponge3d_apply(u1,spo,fdm);
}
}
/* loop over pointers */
ptr_tmp = u0; u0 = u1; u1 = ptr_tmp;
/* extract snapshot */
if (snap && it%jsnap==0) {
int fy = (floor)((sf_o(acy)-fdm->oypad)/fdm->dy);
int jy = floor(sf_d(acy)/fdm->dy);
float **ptr_slice;
for (iy=0; iy<sf_n(acy); iy++) {
ptr_slice = u0[fy+iy*jy];
cut3d_slice(ptr_slice,oslice,fdm,acz,acx);
sf_floatwrite(oslice[0],sf_n(acz)*sf_n(acx),file_wfl);
}
}
/* extract receiver data */
if (sinc) sinc3d_extract(u0,u_dat,crsinc);
else lint3d_extract(u0,u_dat,crlint);
sf_floatwrite(u_dat,nr,file_dat);
#if defined _OPENMP && _DEBUG
toc=omp_get_wtime();
fprintf(stderr,"%5.2gs",(float)(toc-tic));
#endif
}
#ifdef _OPENMP
wall_clock_time_e = omp_get_wtime();
#else
wall_clock_time_e = (double) clock() / CLOCKS_PER_SEC;
#endif
if (verb)
fprintf(stderr,"\nElapsed time: %lf s\n",wall_clock_time_e-wall_clock_time_s);
free(**u0); free(*u0); free(u0);
free(**u1); free(*u1); free(u1);
free(**vel); free(*vel); free(vel);
free(u_dat);
free(ws);
free(fdcoef_d2); free(fdcoef_d1);
if (snap) { free(*oslice); free(oslice); }
if(!cden) { free(**rho); free(*rho); free(rho); }
if (hybrid) free(damp);
free(src3d); free(rec3d);
return 0;
}
int main(int argc, char* argv[])
{
bool inv;
int nt, ny, nx, n1, n2, n3, i4, n4, ntxy;
float o1, d1, o2, d2, o3, d3, eps;
float ***slice, ***tstr, ***ystr, ***xstr, ***slice2;
sf_file in, out, warp;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
warp = sf_input("warp");
if (!sf_getbool("inv",&inv)) inv=true;
/* inversion flag */
if (inv) {
if (!sf_histint(in,"n1",&nt)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&ny)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&nx)) sf_error("No n3= in input");
} else {
if (!sf_histint(warp,"n1",&nt)) sf_error("No n1= in input");
if (!sf_histint(warp,"n2",&ny)) sf_error("No n2= in input");
if (!sf_histint(warp,"n3",&nx)) sf_error("No n3= in input");
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_histint(in,"n3",&n3)) sf_error("No n3= in input");
}
n4 = sf_leftsize(in,3);
ntxy= nt*ny*nx;
if (inv && !sf_getint("n1",&n1)) n1=nt;
if (!sf_getfloat("d1",&d1) && !sf_histfloat(in,"d1",&d1)) d1=1.;
if (!sf_getfloat("o1",&o1) && !sf_histfloat(in,"o1",&o1)) o1=0.;
if (inv && !sf_getint("n2",&n2)) n2=ny;
if (!sf_getfloat("d2",&d2) && !sf_histfloat(in,"d2",&d2)) d2=1.;
if (!sf_getfloat("o2",&o2) && !sf_histfloat(in,"o2",&o2)) o2=0.;
if (inv && !sf_getint("n3",&n3)) n3=nx;
/* output samples - for inv=y */
if (!sf_getfloat("d3",&d3) && !sf_histfloat(in,"d3",&d3)) d3=1.;
/*( d1=1 output sampling - for inv=y )*/
if (!sf_getfloat("o3",&o3) && !sf_histfloat(in,"o3",&o3)) o3=0.;
/*( o1=0 output origin - for inv=y )*/
if (inv) {
sf_putint(out,"n1",n1);
sf_putfloat(out,"d1",d1);
sf_putfloat(out,"o1",o1);
sf_putint(out,"n2",n2);
sf_putfloat(out,"d2",d2);
sf_putfloat(out,"o2",o2);
sf_putint(out,"n3",n3);
sf_putfloat(out,"d3",d3);
sf_putfloat(out,"o3",o3);
} else {
sf_putint(out,"n1",nt);
sf_putint(out,"n2",ny);
sf_putint(out,"n3",nx);
}
if (!sf_getfloat("eps",&eps)) eps=0.01;
/* stretch regularization */
slice = sf_floatalloc3(nt,ny,nx);
tstr = sf_floatalloc3(nt,ny,nx);
xstr = sf_floatalloc3(nt,ny,nx);
ystr = sf_floatalloc3(nt,ny,nx);
slice2 = sf_floatalloc3(n1,n2,n3);
warp3_init(n1, o1, d1,
n2, o2, d2,
n3, o3, d3,
nt, ny, nx, eps);
for (i4=0; i4 < n4; i4++) {
sf_floatread(tstr[0][0],ntxy,warp);
sf_floatread(ystr[0][0],ntxy,warp);
sf_floatread(xstr[0][0],ntxy,warp);
if (inv) {
sf_floatread(slice[0][0],ntxy,in);
warp3(slice,tstr,ystr,xstr,slice2);
sf_floatwrite (slice2[0][0],n1*n2*n3,out);
} else {
sf_floatread(slice2[0][0],n1*n2*n3,in);
fwarp3(slice2,tstr,ystr,xstr,slice);
sf_floatwrite (slice[0][0],ntxy,out);
}
}
exit(0);
}
int main(int argc, char* argv[])
{
int ompnth=1;
sf_file in, out; /* Input and output files */
sf_axis az,ax,a3;
int nz,nx,n3;
int box1,box2,klo1,khi1,klo2,khi2,kmid2,kmid1;
int ix,iz,i3;
float *sumG,***d,***dat,***neg,***dN;
float neg1,AmpNorm,h,h1;
double scalea, logs;
/*---------------------------------------------------------*/
/* Initialize RSF */
sf_init(argc,argv);
/* standard input */
in = sf_input("in");
/* standard output */
out = sf_output("out");
#ifdef _OPENMP
ompnth = omp_init();
#endif
/* parameters from input file*/
az=sf_iaxa(in,1); sf_setlabel(az,"z"); nz = sf_n(az);
ax=sf_iaxa(in,2); sf_setlabel(ax,"x"); nx = sf_n(ax);
a3=sf_iaxa(in,3); sf_setlabel(a3,"y"); n3 = sf_n(a3);
/* parameter from the command line (i.e. box1=50 box2=50 ) */
if (!sf_getint("box1",&box1)) sf_error("Need box1=");
if (!sf_getint("box2",&box2)) sf_error("Need box2=");
/* allocate floating point array */
dat = sf_floatalloc3 (nz,nx,n3);
/* initialise the size of the searching box*/
int s1= nz-(box1);
int s2= nx-(box2);
int bm1=box1/2;
int bm2=box2/2;
/*initialise the mid-point of each box) */
sumG =sf_floatalloc (n3);
d =sf_floatalloc3 (nz,nx,n3);
dN =sf_floatalloc3 (nz,nx,n3);
neg =sf_floatalloc3 (nz,nx,n3);
sf_floatread(dat[0][0],nz*nx*n3,in);
// Global Sum
for (i3=0 ; i3<n3; ++i3){
sumG[i3]=0;
for (ix=0; ix<nx; ++ix){
for (iz=0; iz<nz; ++iz){
d[i3][ix][iz] = dat[i3][ix][iz] * dat[i3][ix][iz]; //make all amplitudes positive
sumG[i3] += d[i3][ix][iz];
}
}
}
/*
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) \
private(klo2,klo1,kmid2,kmid1,khi1,khi2,neg1,AmpNorm,scalea,logs,h1,h)
#endif
*/
//initialise the box for negentropy
for (i3=0 ; i3<n3 ; ++i3 ){
klo2=0;klo1=0;
for (klo2=0; klo2<(s2); ++klo2){
for (klo1=0; klo1<(s1); ++klo1){
//intialise parameters
neg1=0.0;scalea=0.0;logs=0.0;
AmpNorm=0.0;h=0,h1=0;
//Set upper limit of searching box and midpoints
khi2=klo2+box2; khi1=klo1+box1;
kmid2=klo2+bm2; kmid1=klo1+bm1;
//Sum values in each box
for (ix=klo2; ix<khi2; ++ix){
for (iz=klo1; iz<khi1; ++iz){
AmpNorm =(d[i3][ix][iz])/(sumG[i3]);
dN[i3][ix][iz]=AmpNorm; //ai
//Gaussian operator
h =(((iz -kmid1) * (iz -kmid1)) + \
((ix -kmid2) * (ix -kmid2))) / (2*box1*box2*1.41);
h1=(((box1*0.5 ) * (box1*0.5 )) + \
((box2*0.5 ) * (box2*0.5 )))/ (2*box1*box2*1.41);
h =exp(-4*h );
h1=exp(-4*h1);
if (h1>= h) scalea=0;
else
scalea = box1 * box2 * AmpNorm * (h-h1); //qi
if (AmpNorm==0) logs= 0;
else logs= scalea*scalea;
/* logs can be different functions:
else {logs=log(scalea);}
logs=log(scalea); */
neg1 += (scalea*logs);
}
}
neg[i3][kmid2][kmid1] = neg1/(box1*box2);
}
}
}
sf_floatwrite(neg[0][0] ,nz*nx*n3 ,out); //write negentropy
exit(0);
}
int main(int argc, char* argv[])
{
fint1 str, istr;
int i1,i2, n1,n2,n3, ix,iv,ih, ib, ie, nb, nx,nv,nh, nw, next;
float d1,o1,d2,o2, eps, w,x,k, v0,v2,v,v1,dv, dx, h0,dh,h, num, den, t, dw;
float *trace=NULL, *strace=NULL, ***stack=NULL, ***stack2=NULL, ***cont=NULL, **image=NULL;
sf_complex *ctrace=NULL, *ctrace0=NULL, shift;
char *time=NULL, *space=NULL, *unit=NULL;
size_t len;
static kiss_fftr_cfg forw, invs;
sf_file in=NULL, out=NULL;
bool sembl;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&nh)) sf_error("No n3= in input");
if (!sf_getint("nb",&nb)) nb=2;
if (!sf_getfloat("eps",&eps)) eps=0.01;
if (!sf_getint("pad",&n2)) n2=n1;
if (!sf_getint("pad2",&n3)) n3=2*kiss_fft_next_fast_size((n2+1)/2);
nw = n3/2+1;
forw = kiss_fftr_alloc(n3,0,NULL,NULL);
invs = kiss_fftr_alloc(n3,1,NULL,NULL);
if (NULL == forw || NULL == invs)
sf_error("KISS FFT allocation error");
if (!sf_histfloat(in,"o1",&o1)) o1=0.;
o2 = o1*o1;
if(!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input");
d2 = o1+(n1-1)*d1;
d2 = (d2*d2 - o2)/(n2-1);
if (!sf_getint("nv",&nv)) sf_error("Need nv=");
if (!sf_getfloat("dv",&dv)) sf_error("Need dv=");
if (!sf_getfloat("v0",&v0) &&
!sf_histfloat(in,"v0",&v0)) sf_error("Need v0=");
if (!sf_getbool("semblance",&sembl)) sembl=true;
/* if y, compute semblance; if n, stack */
if(!sf_histfloat(in,"o3",&h0)) sf_error("No o2= in input");
if(!sf_histfloat(in,"d3",&dh)) sf_error("No d2= in input");
if(!sf_histfloat(in,"d2",&dx)) sf_error("No d3= in input");
sf_putfloat(out,"o3",v0+dv);
sf_putfloat(out,"d3",dv);
sf_putint(out,"n3",nv);
sf_putstring(out,"label3","Velocity");
if (NULL != (time = sf_histstring(in,"label1")) &&
NULL != (space = sf_histstring(in,"label2"))) {
len = strlen(time)+strlen(space)+2;
unit = sf_charalloc(len);
snprintf(unit,len,"%s/%s",space,time);
sf_putstring(out,"unit3",unit);
free(time);
free(space);
}
dx = 2*SF_PI/(2*kiss_fft_next_fast_size(nx-1)*dx);
dw = 16*SF_PI/(d2*n3); /* 2pi * 8 */
stack = sf_floatalloc3(n1,nx,nv);
stack2 = sf_floatalloc3(n1,nx,nv);
cont = sf_floatalloc3(n1,nx,nv);
image = sf_floatalloc2(n1,nx);
trace = sf_floatalloc(n1);
strace = sf_floatalloc(n3);
ctrace = sf_complexalloc(nw);
ctrace0 = sf_complexalloc(nw);
if (!sf_getint("extend",&next)) next=4;
/* trace extension */
str = fint1_init(next,n1,0);
istr = fint1_init(next,n2,0);
for (i1=0; i1 < n1*nx*nv; i1++) {
stack[0][0][i1] = 0.;
stack2[0][0][i1] = 0.;
}
sf_cosft_init(nx);
for (ih=0; ih < nh; ih++) {
sf_warning("offset %d of %d;",ih+1,nh);
h = h0 + ih*dh;
h *= h * 0.5;
sf_floatread(image[0],n1*nx,in);
for (i1=0; i1 < n1; i1++) {
sf_cosft_frw(image[0],i1,n1);
}
for (ix=0; ix < nx; ix++) {
x = ix*dx;
x *= x;
k = x * 0.5;
fint1_set(str,image[ix]);
for (i2=0; i2 < n2; i2++) {
t = o2+i2*d2;
t = sqrtf(t);
t = (t-o1)/d1;
i1 = t;
if (i1 >= 0 && i1 < n1) {
strace[i2] = fint1_apply(str,i1,t-i1,false);
} else {
strace[i2] = 0.;
}
}
for (i2=n2; i2 < n3; i2++) {
strace[i2] = 0.;
}
kiss_fftr(forw,strace, (kiss_fft_cpx *) ctrace0);
for (iv=0; iv < nv; iv++) {
v = v0 + (iv+1)* dv;
v1 = h * (1./(v*v) - 1./(v0*v0));
v2 = k * ((v0*v0) - (v*v));
ctrace[0]=sf_cmplx(0.,0.); /* dc */
for (i2=1; i2 < nw; i2++) {
w = i2*dw;
w = v2/w+(v1-0.125*o2)*w;
shift = sf_cmplx(cosf(w),sinf(w));
#ifdef SF_HAS_COMPLEX_H
ctrace[i2] = ctrace0[i2] * shift;
#else
ctrace[i2] = sf_cmul(ctrace0[i2],shift);
#endif
} /* w */
kiss_fftri(invs,(const kiss_fft_cpx *) ctrace, strace);
fint1_set(istr,strace);
for (i1=0; i1 < n1; i1++) {
t = o1+i1*d1;
t = t*t;
t = (t-o2)/d2;
i2 = t;
if (i2 >= 0 && i2 < n2) {
cont[iv][ix][i1] = fint1_apply(istr,i2,t-i2,false);
} else {
cont[iv][ix][i1] = 0.;
}
}
} /* v */
} /* x */
for (iv=0; iv < nv; iv++) {
for (i1=0; i1 < n1; i1++) {
sf_cosft_inv(cont[0][0],i1+iv*nx*n1,n1);
}
}
for (iv=0; iv < nv; iv++) {
for (ix=0; ix < nx; ix++) {
for (i1=0; i1 < n1; i1++) {
t = cont[iv][ix][i1];
stack[iv][ix][i1] += t;
stack2[iv][ix][i1] += t*t;
} /* i1 */
} /* x */
} /* v */
} /* h */
sf_warning(".");
for (iv=0; iv < nv; iv++) {
for (ix=0; ix < nx; ix++) {
for (i1=0; i1 < n1; i1++) {
ib = i1-nb > 0? i1-nb: 0;
ie = i1+nb+1 < n1? i1+nb+1: n1;
num = 0.;
den = 0.;
if (sembl) {
for (i2=ib; i2 < ie; i2++) {
t = stack[iv][ix][i2];
num += t*t;
den += stack2[iv][ix][i2];
}
den *= nh;
trace[i1] = den > 0.? num/den: 0.;
} else {
for (i2=ib; i2 < ie; i2++) {
t = stack[iv][ix][i2];
num += t;
}
den = nh;
trace[i1] = num/(den+ FLT_EPSILON);
}
}
sf_floatwrite (trace,n1,out);
}
}
exit(0);
}
int main(int argc, char *argv[])
{
clock_t tstart, tend;
double duration;
int numprocs, rank;
float *sendbuf, *recvbuf;
MPI_Comm Comm=MPI_COMM_WORLD;
bool verb, wantrecord, wantwf, onlyrecord;
sf_file Ffvel, Ffden, Fbvel, Fbden;
sf_file Fsrc, Frcd, Fimg1, Fimg2;
sf_file FGx, FGz, Fsxx, Fsxz, Fszx, Fszz;
sf_file Ftmpfwf, Ftmpbwf;
sf_axis at, ax, az, atau;
int shtbgn, shtinv, shtnmb, shtpad, shtnmb0;
int snapturn, tmpint;
float **fvel, **bvel;
float ***fwf, ***record, **localrec;
float ***img1, **img2, ***mig1, **mig2;
float *tmpsxx, *tmpsxz, *tmpszx, *tmpszz;
sf_init(argc, argv);
MPI_Init(&argc, &argv);
MPI_Comm_size(Comm, &numprocs);
MPI_Comm_rank(Comm, &rank);
tstart=clock();
if(rank==0) sf_warning("numprocs=%d", numprocs);
if(!sf_getbool("verb", &verb)) verb=true;
if(!sf_getbool("wantrecord", &wantrecord)) wantrecord=false;
if(!sf_getbool("wantwf", &wantwf)) wantwf=false;
if(!sf_getbool("onlyrecord", &onlyrecord)) onlyrecord=false;
Fsrc=sf_input("-input");
Fimg1=sf_output("-output");
Fimg2=sf_output("img2");
Ffvel=sf_input("fvel");
Ffden=sf_input("fden");
Fbvel=sf_input("bvel");
Fbden=sf_input("bden");
if(wantrecord)
Frcd=sf_input("record");
else
Frcd=sf_output("record");
if(wantwf){
Ftmpfwf=sf_output("tmpfwf");
Ftmpbwf=sf_output("tmpbwf");
}
FGx=sf_input("Gx");
FGz=sf_input("Gz");
Fsxx=sf_input("sxx");
Fsxz=sf_input("sxz");
Fszx=sf_input("szx");
Fszz=sf_input("szz");
at=sf_iaxa(Fsrc, 1); nt=sf_n(at); dt=sf_d(at);
if(!sf_getbool("srcdecay", &srcdecay)) srcdecay=true;
if(!sf_getint("srcrange", &srcrange)) srcrange=3;
if(!sf_getfloat("srctrunc", &srctrunc)) srctrunc=0.2;
if(!sf_getfloat("srcalpha", &srcalpha)) srcalpha=0.5;
wavelet=sf_floatalloc(nt);
sf_floatread(wavelet, nt, Fsrc);
if(!sf_getint("pmlsize", &pmlsize)) pmlsize=30;
if(!sf_getint("nfd", &nfd)) sf_error("Need half of the FD order!");
if(!sf_getfloat("pmld0", &pmld0)) pmld0=200;
if(!sf_getint("shtnmb", &shtnmb)) sf_error("Need shot number!");
if(!sf_getint("shtinv", &shtinv)) sf_error("Need shot interval!");
if(!sf_getint("shtbgn", &shtbgn)) shtbgn=0;
shtpad=numprocs-shtnmb%numprocs;
shtnmb0=shtnmb+shtpad;
az=sf_iaxa(Ffvel, 1); nzb=sf_n(az);
ax=sf_iaxa(Ffvel, 2); nxb=sf_n(ax);
nxzb=nxb*nzb;
nz=nzb-2*nfd-2*pmlsize;
nx=nxb-2*nfd-2*pmlsize;
if(!sf_getint("snapturn", &snapturn)) snapturn=1;
if(!sf_getint("ginv", &ginv)) ginv=1;
if(!sf_getint("wfinv", &wfinv)) wfinv=1;
if(!sf_getint("spz", &spz)) spz=6;
if(!sf_getint("gp", &gp)) gp=0;
ng=(nx-1)/ginv+1;
wfnt=(nt-1)/wfinv+1;
wfdt=dt*wfinv;
if(!sf_getint("ntau", &ntau)) ntau=1;
if(!sf_getfloat("dtau", &dtau)) dtau=wfdt;
if(!sf_getfloat("tau0", &tau0)) tau0=0;
atau=sf_iaxa(Fsrc, 1);
sf_setn(atau, ntau);
sf_setd(atau, dtau);
sf_seto(atau, tau0);
if(!sf_histint(FGx, "n1", &nxz)) sf_error("No n1= in FGx!");
if(nxz != nxzb) sf_error("Dimension error!");
if(!sf_histint(FGx, "n2", &lenx)) sf_error("No n2= in FGx!");
if(!sf_histint(FGz, "n2", &lenz)) sf_error("No n2= in FGz!");
Gx=sf_floatalloc3(nzb, nxb, lenx);
Gz=sf_floatalloc3(nzb, nxb, lenz);
sxx=sf_intalloc(lenx);
sxz=sf_intalloc(lenx);
szx=sf_intalloc(lenz);
szz=sf_intalloc(lenz);
tmpsxx=sf_floatalloc(lenx);
tmpsxz=sf_floatalloc(lenx);
tmpszx=sf_floatalloc(lenz);
tmpszz=sf_floatalloc(lenz);
sf_floatread(Gx[0][0], nxzb*lenx, FGx);
sf_floatread(Gz[0][0], nxzb*lenz, FGz);
sf_floatread(tmpsxx, lenx, Fsxx);
sf_floatread(tmpsxz, lenx, Fsxz);
sf_floatread(tmpszx, lenz, Fszx);
sf_floatread(tmpszz, lenz, Fszz);
for (ix=0; ix<lenx; ix++){
sxx[ix]=(int)tmpsxx[ix];
sxz[ix]=(int)tmpsxz[ix];
}
for (iz=0; iz<lenz; iz++){
szx[iz]=(int)tmpszx[iz];
szz[iz]=(int)tmpszz[iz];
}
fvel=sf_floatalloc2(nzb, nxb);
fden=sf_floatalloc2(nzb, nxb);
fc11=sf_floatalloc2(nzb, nxb);
bvel=sf_floatalloc2(nzb, nxb);
bden=sf_floatalloc2(nzb, nxb);
bc11=sf_floatalloc2(nzb, nxb);
sf_floatread(fvel[0], nxzb, Ffvel);
sf_floatread(fden[0], nxzb, Ffden);
sf_floatread(bvel[0], nxzb, Fbvel);
sf_floatread(bden[0], nxzb, Fbden);
for (ix=0; ix<nxb; ix++){
for (iz=0; iz<nzb; iz++){
fc11[ix][iz]=fden[ix][iz]*fvel[ix][iz]*fvel[ix][iz];
bc11[ix][iz]=bden[ix][iz]*bvel[ix][iz]*bvel[ix][iz];
}
}
if(wantrecord){
/* check record data */
sf_histint(Frcd, "n1", &tmpint);
if(tmpint != nt) sf_error("Not matched dimensions!");
sf_histint(Frcd, "n2", &tmpint);
if(tmpint != ng) sf_error("Not matched dimensions!");
sf_histint(Frcd, "n3", &tmpint);
if(tmpint != shtnmb) sf_error("Not matched dimensions!");
}
if(rank==0){
record=sf_floatalloc3(nt, ng, shtnmb0);
if(wantrecord){
sf_floatread(record[0][0], nt*ng*shtnmb, Frcd);
for(is=shtnmb; is<shtnmb0; is++)
for(ix=0; ix<ng; ix++)
for(it=0; it<nt; it++)
record[is][ix][it]=0.0;
}
}
img1=sf_floatalloc3(nz, nx, ntau);
mig1=sf_floatalloc3(nz, nx, ntau);
img2=sf_floatalloc2(nz, nx);
mig2=sf_floatalloc2(nz, nx);
zero3(img1, nz, nx, ntau);
zero2(img2, nz, nx);
sf_setn(az, nz);
sf_setn(ax, ng);
if(!wantrecord){
sf_oaxa(Frcd, at, 1);
sf_oaxa(Frcd, ax, 2);
sf_putint(Frcd, "n3", shtnmb);
sf_putint(Frcd, "d3", shtinv);
sf_putint(Frcd, "o3", shtbgn);
}
sf_setn(ax, nx);
if(wantwf){
sf_setn(at, wfnt);
sf_setd(at, wfdt);
sf_oaxa(Ftmpfwf, az, 1);
sf_oaxa(Ftmpfwf, ax, 2);
sf_oaxa(Ftmpfwf, at, 3);
sf_oaxa(Ftmpbwf, az, 1);
sf_oaxa(Ftmpbwf, ax, 2);
sf_oaxa(Ftmpbwf, at, 3);
}
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);
fwf=sf_floatalloc3(nz, nx, wfnt);
localrec=sf_floatalloc2(nt, ng);
if(verb){
sf_warning("==================================");
sf_warning("nx=%d nz=%d nt=%d", nx, nz, nt);
sf_warning("wfnt=%d wfdt=%f wfinv=%d dt=%f", wfnt, wfdt, wfinv, dt);
sf_warning("nxb=%d nzb=%d pmlsize=%d nfd=%d", nxb, nzb, pmlsize, nfd);
sf_warning("ntau=%d dtau=%f tau0=%f", ntau, dtau, tau0);
sf_warning("shtnmb=%d shtbgn=%d shtinv=%d", shtnmb, shtbgn, shtinv);
sf_warning("lenx=%d lenz=%d spz=%d gp=%d", lenx, lenz, spz, gp);
sf_warning("==================================");
}
init();
for(iturn=0; iturn*numprocs<shtnmb; iturn++){
is=iturn*numprocs+rank;
if(is<shtnmb){
sf_warning("ishot/nshot: %d/%d", is+1, shtnmb);
spx=is*shtinv+shtbgn;
sglfdfor2(fwf, localrec, verb);
}
if(wantrecord){
recvbuf=localrec[0];
if(rank==0) sendbuf=record[iturn*numprocs][0];
else sendbuf=NULL;
MPI_Scatter(sendbuf, ng*nt, MPI_FLOAT, recvbuf, ng*nt, MPI_FLOAT, 0, Comm);
}else{
sendbuf=localrec[0];
if(rank==0) recvbuf=record[iturn*numprocs][0];
else recvbuf=NULL;
MPI_Gather(sendbuf, ng*nt, MPI_FLOAT, recvbuf, ng*nt, MPI_FLOAT, 0, Comm);
}
if(wantwf && rank==0 && iturn==snapturn-1) wantwf=true;
else wantwf=false;
if(wantwf) sf_floatwrite(fwf[0][0], wfnt*nx*nz, Ftmpfwf);
if(!onlyrecord && is<shtnmb){
sglfdback2(mig1, mig2, fwf, localrec, verb, wantwf, Ftmpbwf);
for(itau=0; itau<ntau; itau++){
for(ix=0; ix<nx; ix++){
for(iz=0; iz<nz; iz++){
img1[itau][ix][iz]+=mig1[itau][ix][iz];
}
}
}
for(ix=0; ix<nx; ix++){
for(iz=0; iz<nz; iz++){
img2[ix][iz]+=mig2[ix][iz];
}
}
}
MPI_Barrier(Comm);
} //end of iturn
if(!onlyrecord){
if(rank==0){
sendbuf=(float *)MPI_IN_PLACE;
recvbuf=img1[0][0];
}else{
sendbuf=img1[0][0];
recvbuf=NULL;
}
MPI_Reduce(sendbuf, recvbuf, ntau*nx*nz, MPI_FLOAT, MPI_SUM, 0, Comm);
if(rank==0){
sendbuf=MPI_IN_PLACE;
recvbuf=img2[0];
}else{
sendbuf=img2[0];
recvbuf=NULL;
}
MPI_Reduce(sendbuf, recvbuf, nx*nz, MPI_FLOAT, MPI_SUM, 0, Comm);
}
if(rank==0){
if(!wantrecord){
sf_floatwrite(record[0][0], shtnmb*ng*nt, Frcd);
}
sf_floatwrite(img1[0][0], ntau*nx*nz, Fimg1);
sf_floatwrite(img2[0], nx*nz, Fimg2);
}
tend=clock();
duration=(double)(tend-tstart)/CLOCKS_PER_SEC;
sf_warning(">>The CPU time of sfmpilfdrtm2 is: %f seconds<<", duration);
MPI_Finalize();
exit(0);
}
int main(int argc, char* argv[])
{
bool verb;
sf_file Fu,Fw; /* I/O files */
sf_axis a1,a2,a3; /* cube axes */
float ***uu=NULL, ***ww=NULL;
int *ii,ik;
int nh1,nh2,nh3;
int nb1,nb2,nb3;
int ih1,ih2,ih3;
int ib1,ib2,ib3;
int n3;
int i3;
int j1, j2, j3;
int k1, k2, k3;
int ompchunk;
int lo1,hi1;
int lo2,hi2;
int lo3,hi3;
/*------------------------------------------------------------*/
/* init RSF */
sf_init(argc,argv);
if(! sf_getint("ompchunk",&ompchunk)) ompchunk=1; /* OpenMP data chunk size */
if(! sf_getbool("verb",&verb)) verb=false; /* verbosity flag */
Fu = sf_input ("in" ); /* input field */
Fw = sf_output("out"); /* wigner distribution */
/* read axes */
a1=sf_iaxa(Fu,1); sf_setlabel(a1,"a1"); if(verb) sf_raxa(a1);
a2=sf_iaxa(Fu,2); sf_setlabel(a2,"a2"); if(verb) sf_raxa(a2);
a3=sf_iaxa(Fu,3); sf_setlabel(a3,"a3"); if(verb) sf_raxa(a3);
n3 = sf_n(a3);
if(! sf_getint("nh1",&nh1)) nh1=0;
if(! sf_getint("nh2",&nh2)) nh2=0;
if(! sf_getint("nh3",&nh3)) nh3=0;
if(n3<=1) nh3=0;
if(verb) sf_warning("nh1=%d nh2=%d nh3=%d",2*nh1+1,2*nh2+1,2*nh3+1);
nb1 = sf_n(a1);
nb2 = sf_n(a2);
nb3=2*nh3+1;
uu=sf_floatalloc3(nb1,nb2,nb3);
ww=sf_floatalloc3(nb1,nb2,nb3);
ii = sf_intalloc(nb3);
for(ib3=0;ib3<nb3;ib3++) {
ii[ib3]=ib3;
}
/*------------------------------------------------------------*/
/* low end on axis 3 */
/*------------------------------------------------------------*/
for( ib3=0; ib3<nb3; ib3++) {
for( ib2=0; ib2<nb2; ib2++) {
for( ib1=0; ib1<nb1; ib1++) {
ww[ib3][ib2][ib1] = 0.;
}
}
}
sf_floatread(uu[0][0],nb1*nb2*nb3,Fu);
for( ih3=-nh3; ih3<nh3+1; ih3++) { lo3=SF_ABS(ih3); hi3=nb3-lo3;
for( ih2=-nh2; ih2<nh2+1; ih2++) { lo2=SF_ABS(ih2); hi2=nb2-lo2;
for(ih1=-nh1; ih1<nh1+1; ih1++) { lo1=SF_ABS(ih1); hi1=nb1-lo1;
for( ib3=lo3; ib3<nh3+1;ib3++) { j3=ii[ib3-ih3]; k3=ii[ib3+ih3];
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic,ompchunk) \
private(ib1,ib2,j2,j1,k2,k1) \
shared(ib3,j3,k3,ih2,ih1,lo2,hi2,lo1,hi1,uu,ww)
#endif
for( ib2=lo2; ib2<hi2; ib2++) { j2=ib2-ih2; k2=ib2+ih2;
for(ib1=lo1; ib1<hi1; ib1++) { j1=ib1-ih1; k1=ib1+ih1;
ww[ib3][ib2][ib1] += uu[j3][j2][j1]
* uu[k3][k2][k1];
} /* nb1 */
} /* nb2 */
} /* nb3 */
} /* nh1 */
} /* nh2 */
} /* nh3 */
for(ih3=0;ih3<nh3+1;ih3++) {
sf_floatwrite(ww[ih3][0],nb1*nb2,Fw);
}
/*------------------------------------------------------------*/
/* loop on axis 3 */
/*------------------------------------------------------------*/
if(verb) fprintf(stderr," n3\n");
if(verb) fprintf(stderr,"%5d\n",n3-1);
for(i3=nh3+1;i3<n3-nh3;i3++) {
if(verb) fprintf(stderr,"%5d",i3);
/* zero WDF */
ib3=nh3;
for( ib2=0; ib2<nb2; ib2++) {
for( ib1=0; ib1<nb1; ib1++) {
ww[ib3][ib2][ib1] = 0.;
}
}
/* circulate index to slices */
ik = ii[0];
for(ib3=0;ib3<nb3-1;ib3++) {
ii[ib3]=ii[ib3+1];
}
ii[nb3-1]=ik;
/* read new slice */
sf_floatread(uu[ ii[nb3-1] ][0],nb1*nb2,Fu);
for( ih3=-nh3; ih3<nh3+1; ih3++) {
for( ih2=-nh2; ih2<nh2+1; ih2++) { lo2=SF_ABS(ih2); hi2=nb2-lo2;
for(ih1=-nh1; ih1<nh1+1; ih1++) { lo1=SF_ABS(ih1); hi1=nb1-lo1;
ib3=nh3; j3=ii[ib3-ih3]; k3=ii[ib3+ih3];
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic,ompchunk) \
private(ib1,ib2,j2,j1,k2,k1) \
shared(ib3,j3,k3,ih2,ih1,lo2,hi2,lo1,hi1,uu,ww)
#endif
for( ib2=lo2; ib2<hi2; ib2++) { j2=ib2-ih2; k2=ib2+ih2;
for(ib1=lo1; ib1<hi1; ib1++) { j1=ib1-ih1; k1=ib1+ih1;
ww[ib3][ib2][ib1] += uu[j3][j2][j1]
* uu[k3][k2][k1];
} /* nb1 */
} /* nb2 */
} /* nh1 */
} /* nh2 */
} /* nh3 */
sf_floatwrite(ww[nh3][0],nb1*nb2,Fw);
if(verb) fprintf(stderr,"\b\b\b\b\b");
}
/*------------------------------------------------------------*/
/* high-end on axis 3*/
/*------------------------------------------------------------*/
for( ih3=-nh3; ih3<nh3+1; ih3++) { lo3=SF_ABS(ih3); hi3=nb3-lo3;
for( ih2=-nh2; ih2<nh2+1; ih2++) { lo2=SF_ABS(ih2); hi2=nb2-lo2;
for(ih1=-nh1; ih1<nh1+1; ih1++) { lo1=SF_ABS(ih1); hi1=nb1-lo1;
for( ib3=nh3+1; ib3<hi3; ib3++) { j3=ii[ib3-ih3]; k3=ii[ib3+ih3];
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic,ompchunk) \
private(ib1,ib2,j2,j1,k2,k1) \
shared(ib3,j3,k3,ih2,ih1,lo2,hi2,lo1,hi1,uu,ww)
#endif
for( ib2=lo2; ib2<hi2; ib2++) { j2=ib2-ih2; k2=ib2+ih2;
for(ib1=lo1; ib1<hi1; ib1++) { j1=ib1-ih1; k1=ib1+ih1;
ww[ib3][ib2][ib1] += uu[j3][j2][j1]
* uu[k3][k2][k1];
} /* nb1 */
} /* nb2 */
} /* nb3 */
} /* nh1 */
} /* nh2 */
} /* nh3 */
for(ih3=nh3+1;ih3<2*nh3+1;ih3++) {
sf_floatwrite(ww[ih3][0],nb1*nb2,Fw);
}
/*------------------------------------------------------------*/
exit (0);
}
int main(int argc,char **argv)
{
int isx,isy,isz,bd;
int i,j,k,im,jm,it;
int nth, rank;
float t;
float fx,fy,fz,dt2;
float ***c11, ***c22, ***c33, ***c12, ***c13, ***c23, ***c44, ***c55, ***c66;
float ***phaix, ***phaiy, ***phaiz;
sf_init(argc,argv);
sf_file Fo1, Fo2, Fo3;
float f0=40; // main frequency of the wavelet(usually 30Hz)
float t0=0.04; // time delay of the wavelet(if f0=30Hz, t0=0.04s)*/
float A=1.0; // the amplitude of wavelet
clock_t t1, t2, t3;
float timespent;
t1=clock();
/* time samping paramter */
if (!sf_getint("nt",&nt)) nt=301;
if (!sf_getfloat("dt",&dt)) dt=0.001;
if (!sf_getint("bd",&bd)) bd=20;
sf_warning("nt=%d dt=%f",nt,dt);
/* setup I/O files */
sf_file Fc11, Fc22, Fc33, Fc12, Fc13, Fc23, Fc44, Fc55, Fc66;
sf_file Fphiz, Fphiy, Fphix;
Fc11 = sf_input ("c11"); /* c11 using standard input */
Fc22 = sf_input ("c22"); /* c22 */
Fc33 = sf_input ("c33"); /* c33 */
Fc12 = sf_input ("c12"); /* c12 */
Fc13 = sf_input ("c13"); /* c13 */
Fc23 = sf_input ("c23"); /* c23 */
Fc44 = sf_input ("c44"); /* c44 */
Fc55 = sf_input ("c55"); /* c55 */
Fc66 = sf_input ("c66"); /* c66 */
Fphix = sf_input ("phix"); /* phix x ccw*/
Fphiy = sf_input ("phiy"); /* phiy y ccw*/
Fphiz = sf_input ("phiz"); /* phiz z ccw */
/* Read/Write axes */
sf_axis az, ax, ay;
az = sf_iaxa(Fc11,1); nz = sf_n(az); dz = sf_d(az)*1000.0;
ax = sf_iaxa(Fc11,2); nx = sf_n(ax); dx = sf_d(ax)*1000.0;
ay = sf_iaxa(Fc11,3); ny = sf_n(ay); dy = sf_d(ay)*1000.0;
fy=sf_o(ay)*1000.0;
fx=sf_o(ax)*1000.0;
fz=sf_o(az)*1000.0;
int nxpad, nypad, nzpad;
nxpad=nx+2*bd;
nypad=ny+2*bd;
nzpad=nz+2*bd;
sf_warning("nxpad=%d nypad=%d nzpad=%d ",nxpad,nypad,nzpad);
sf_warning("dx=%f dy=%f dz=%f ",dx,dy,dz);
c11=sf_floatalloc3(nzpad,nxpad,nypad);
c22=sf_floatalloc3(nzpad,nxpad,nypad);
c33=sf_floatalloc3(nzpad,nxpad,nypad);
c12=sf_floatalloc3(nzpad,nxpad,nypad);
c13=sf_floatalloc3(nzpad,nxpad,nypad);
c23=sf_floatalloc3(nzpad,nxpad,nypad);
c44=sf_floatalloc3(nzpad,nxpad,nypad);
c55=sf_floatalloc3(nzpad,nxpad,nypad);
c66=sf_floatalloc3(nzpad,nxpad,nypad);
phaix=sf_floatalloc3(nzpad,nxpad,nypad);
phaiy=sf_floatalloc3(nzpad,nxpad,nypad);
phaiz=sf_floatalloc3(nzpad,nxpad,nypad);
/* read velocity model */
for(i=bd;i<nypad-bd;i++)
for(j=bd;j<nxpad-bd;j++){
sf_floatread(&c11[i][j][bd],nz,Fc11);
sf_floatread(&c22[i][j][bd],nz,Fc22);
sf_floatread(&c33[i][j][bd],nz,Fc33);
sf_floatread(&c12[i][j][bd],nz,Fc12);
sf_floatread(&c13[i][j][bd],nz,Fc13);
sf_floatread(&c23[i][j][bd],nz,Fc23);
sf_floatread(&c44[i][j][bd],nz,Fc44);
sf_floatread(&c55[i][j][bd],nz,Fc55);
sf_floatread(&c66[i][j][bd],nz,Fc66);
sf_floatread(&phaix[i][j][bd],nz,Fphix);
sf_floatread(&phaiy[i][j][bd],nz,Fphiy);
sf_floatread(&phaiz[i][j][bd],nz,Fphiz);
}
vmodelboundary3d(c11, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(c22, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(c33, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(c12, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(c13, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(c23, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(c44, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(c55, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(c66, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(phaix, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(phaiy, nx, ny, nz, nxpad, nypad, nzpad, bd);
vmodelboundary3d(phaiz, nx, ny, nz, nxpad, nypad, nzpad, bd);
for(i=0;i<nypad;i++)
for(j=0;j<nxpad;j++)
for(k=0;k<nzpad;k++){
phaix[i][j][k] *= SF_PI/180.0;
phaiy[i][j][k] *= SF_PI/180.0;
phaiz[i][j][k] *= SF_PI/180.0;
}
sf_warning("Read velocity model parameters ok !");
int mm=2*_m+1;
int mmix=2*_mix+1;
sf_warning("m=%d mix=%d",_m,_mix);
float *coeff_2dx,*coeff_2dy,*coeff_2dz,*coeff_1dx,*coeff_1dy,*coeff_1dz;
coeff_2dy=sf_floatalloc(mm);
coeff_2dx=sf_floatalloc(mm);
coeff_2dz=sf_floatalloc(mm);
coeff_1dy=sf_floatalloc(mmix);
coeff_1dx=sf_floatalloc(mmix);
coeff_1dz=sf_floatalloc(mmix);
coeff2d(coeff_2dx,dx);
coeff2d(coeff_2dy,dy);
coeff2d(coeff_2dz,dz);
coeff1dmix(coeff_1dx, dx);
coeff1dmix(coeff_1dy, dy);
coeff1dmix(coeff_1dz, dz);
float*** p1=sf_floatalloc3(nzpad,nxpad,nypad);
float*** p2=sf_floatalloc3(nzpad,nxpad,nypad);
float*** p3=sf_floatalloc3(nzpad,nxpad,nypad);
zero3float(p1,nzpad,nxpad,nypad);
zero3float(p2,nzpad,nxpad,nypad);
zero3float(p3,nzpad,nxpad,nypad);
float*** q1=sf_floatalloc3(nzpad,nxpad,nypad);
float*** q2=sf_floatalloc3(nzpad,nxpad,nypad);
float*** q3=sf_floatalloc3(nzpad,nxpad,nypad);
zero3float(q1,nzpad,nxpad,nypad);
zero3float(q2,nzpad,nxpad,nypad);
zero3float(q3,nzpad,nxpad,nypad);
float*** r1=sf_floatalloc3(nzpad,nxpad,nypad);
float*** r2=sf_floatalloc3(nzpad,nxpad,nypad);
float*** r3=sf_floatalloc3(nzpad,nxpad,nypad);
zero3float(r1,nzpad,nxpad,nypad);
zero3float(r2,nzpad,nxpad,nypad);
zero3float(r3,nzpad,nxpad,nypad);
t2=clock();
/* setup I/O files */
Fo1 = sf_output("out"); /* original elasticwave iLine x-component */
Fo2 = sf_output("Elasticy"); /* original elasticwave iLine y-component */
Fo3 = sf_output("Elasticz"); /* original elasticwave xLine z-component */
puthead3x(Fo1, nz, nx, ny, dz/1000.0, dx/1000.0, dy/1000.0, 0.0, 0.0, 0.0);
puthead3x(Fo2, nz, nx, ny, dz/1000.0, dx/1000.0, dy/1000.0, 0.0, 0.0, 0.0);
puthead3x(Fo3, nz, nx, ny, dz/1000.0, dx/1000.0, dy/1000.0, 0.0, 0.0, 0.0);
/* source definition */
isy=nypad/2;
isx=nxpad/2;
isz=nzpad/2;
dt2=dt*dt;
#ifdef _OPENMP
#pragma omp parallel
{
nth = omp_get_num_threads();
rank = omp_get_thread_num();
sf_warning("Using %d threads, this is %dth thread",nth, rank);
}
#endif
float*** px_tmp=sf_floatalloc3(nzpad,nxpad,nypad);
float*** pz_tmp=sf_floatalloc3(nzpad,nxpad,nypad);
float*** qx_tmp=sf_floatalloc3(nzpad,nxpad,nypad);
float*** qz_tmp=sf_floatalloc3(nzpad,nxpad,nypad);
float*** rx_tmp=sf_floatalloc3(nzpad,nxpad,nypad);
float*** rz_tmp=sf_floatalloc3(nzpad,nxpad,nypad);
/*********the kernel calculation ************/
for(it=0;it<nt;it++)
{
t=it*dt;
/* source Type 0: oriented 45 degree to vertical and 45 degree azimuth: Yan & Sava (2012) */
p2[isy][isx][isz]+=Ricker(t, f0, t0, A); // x-component
q2[isy][isx][isz]+=Ricker(t, f0, t0, A); // y-component
r2[isy][isx][isz]+=Ricker(t, f0, t0, A); // z-component
// 3D exploding force source (e.g., Wu's PhD
/* for(k=-1;k<=1;k++)*/
/* for(i=-1;i<=1;i++)*/
/* for(j=-1;j<=1;j++)*/
/* {*/
/* if(fabs(i)+fabs(j)+fabs(k)==3)*/
/* {*/
/* p2[isy+k][isx+i][isz+j]+=i*Ricker(t, f0, t0, A); // x-component*/
/* q2[isy+k][isx+i][isz+j]+=k*Ricker(t, f0, t0, A); // y-component*/
/* r2[isy+k][isx+i][isz+j]+=j*Ricker(t, f0, t0, A); // z-component*/
/* }*/
/* }*/
fwportelastic3d(dt2,p1,p2,p3,q1,q2,q3,r1,r2,r3,
px_tmp,pz_tmp,
qx_tmp,qz_tmp,
rx_tmp,rz_tmp,
coeff_2dx,coeff_2dy,coeff_2dz,
coeff_1dx,coeff_1dy,coeff_1dz,
dx,dy,dz,nxpad,nypad,nzpad,
c11,c22,c33,c12,c13,c23,c44,c55,c66,phaix,phaiy,phaiz);
if(it==nt-1) // output snapshot
{
// output iLine
for(i=0;i<ny;i++)
{
im=i+bd;
for(j=0;j<nx;j++)
{
jm=j+bd;
sf_floatwrite(&p3[im][jm][bd],nz,Fo1);
sf_floatwrite(&q3[im][jm][bd],nz,Fo2);
sf_floatwrite(&r3[im][jm][bd],nz,Fo3);
}
}
}
for(i=0;i<nypad;i++)
for(j=0;j<nxpad;j++)
for(k=0;k<nzpad;k++)
{
p1[i][j][k]=p2[i][j][k];
p2[i][j][k]=p3[i][j][k];
q1[i][j][k]=q2[i][j][k];
q2[i][j][k]=q3[i][j][k];
r1[i][j][k]=r2[i][j][k];
r2[i][j][k]=r3[i][j][k];
}
sf_warning("forward propagation... it= %d t=%f",it,t);
}
printf("ok3\n");
t3=clock();
timespent=(float)(t3-t2)/CLOCKS_PER_SEC;
sf_warning("CPU time for 3D ORT elastic modeling: %f(second)",timespent);
free(**p1);
free(**p2);
free(**p3);
free(**q1);
free(**q2);
free(**q3);
free(**r1);
free(**r2);
free(**r3);
free(**px_tmp);
free(**qx_tmp);
free(**rx_tmp);
free(**pz_tmp);
free(**qz_tmp);
free(**rz_tmp);
free(**c11);
free(**c33);
free(**c13);
free(**c55);
free(**c66);
free(**phaiz);
free(**phaiy);
free(**phaix);
return 0;
}
int main(int argc, char* argv[])
{
int i, n1, n2, n12, n3, nk, n12k, niter, nliter, iter, i3, order;
float eps, *d, *s, ***pp, *w=NULL, *p=NULL;
bool verb;
sf_file in, out, dips, weight=NULL;
sf_init (argc,argv);
in = sf_input("in");
dips = sf_input("dips");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n3 = sf_leftsize(in,2);
if (!sf_histint(dips,"n1",&i) || i != n1) sf_error("Wrong n1= in dips");
if (!sf_histint(dips,"n2",&i) || i != n2) sf_error("Wrong n2= in dips");
if (sf_histint(dips,"n4",&i) && i != n3) sf_error("Wrong n4= in dips");
if (!sf_histint(dips,"n3",&nk)) nk=1;
sf_putint (out,"n3",nk);
sf_putint (out,"n4",n3);
n12 = n1*n2;
n12k = n12*nk;
if (!sf_getint ("niter",&niter)) niter=50;
/* maximum number of iterations */
if (!sf_getint ("nliter",&nliter)) nliter=1;
/* number of reweighting iterations */
if (!sf_getfloat ("eps",&eps)) eps=0.;
/* regularization parameter */
if (!sf_getbool("verb",&verb)) verb = false;
/* verbosity flag */
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
s = sf_floatalloc(n12k);
d = sf_floatalloc(n12);
pp = sf_floatalloc3(n1,n2,nk);
if (nliter > 1) {
w = sf_floatalloc(n12k);
p = sf_floatalloc(n12k);
if (NULL != sf_getstring("weight")) {
weight = sf_output("weight");
sf_putint(weight,"n3",nk);
sf_putint(weight,"n4",n3);
}
}
predk_init(nk,n1,n2,0.0001,order,pp);
copyk_init(nk,n12);
for (i3=0; i3 < n3; i3++) {
if (verb) sf_warning("slice %d of %d",i3+1,n3);
sf_floatread (d,n12,in);
sf_floatread (pp[0][0],n12k,dips);
if (1 == nliter) {
sf_solver_prec (copyk_lop,sf_cgstep,predk_lop,
n12k,n12k,n12,s,d,niter,eps,"verb",verb,"end");
sf_cgstep_close();
} else {
for (i=0; i < n12k; i++) {
w[i] = 1.;
}
for (iter=0; iter < nliter; iter++) {
sf_solver_prec (copyk_lop,sf_cgstep,predk_lop,
n12k,n12k,n12,s,d,niter,eps,
"verb",verb,"mwt",w,"xp",p,"end");
sf_cgstep_close();
if (iter < nliter-1) {
for (i=0; i < n12k; i++) {
w[i] = fabsf(p[i]); /* "Cauchy" weight */
}
} else {
for (i=0; i < n12k; i++) {
w[i] *= p[i];
}
}
}
if (NULL != weight) sf_floatwrite(w,n12k,weight);
}
sf_floatwrite(s,n12k,out);
}
exit(0);
}
