// Finds smallest root greater than given lower bound.
// Assumes there exists exactly one root with this property.
// (Impossible to solve equations if roots have same integer part at
// the moment. Don't do that.)
// TODO: Rewrite so you choose if you want smaller or greater root.
// or so it returns both solutions in an array.
static void *newton(cf_t cf) {
newton_data_ptr nd = cf_data(cf);
abc_t p;
abc_init(p);
abc_set_coeff(p, nd->a);
cf_t x = nd->x;
mpz_t z, z0, z1, one, pow2, t0, t1, t2;
mpz_init(z); mpz_init(z0); mpz_init(z1); mpz_init(pow2);
mpz_init(t0); mpz_init(t1); mpz_init(t2);
mpz_init(one);
mpz_set_ui(one, 1);
void move_right() {
cf_get(z, x);
mpz_mul(t0, z, p->b1);
mpz_add(t0, t0, p->b0);
mpz_set(p->b0, p->b1);
mpz_set(p->b1, t0);
mpz_mul(t0, z, p->a1); mpz_mul(t1, z, p->c1);
mpz_add(t0, t0, p->a0); mpz_add(t1, t1, p->c0);
mpz_set(p->a0, p->a1); mpz_set(p->c0, p->c1);
mpz_set(p->a1, t0); mpz_set(p->c1, t1);
}
int main(int argc, char* argv[])
{
bool verb,pas,adj,abc; /* execution flags */
int ix, iz, it; /* index variables */
int nt, nx, nz, depth, nzxpad, nb, n2, snap;
float ox, oz, dx, dz, dt, dt2, idz2, idx2, cb;
int nxpad, nzpad;
float **vvpad;
float **dd, **mm, **vv, ***ww;
float **u0, **u1, **u2, **tmp; /* temporary arrays */
sf_file in, out, vel, wave; /* I/O files */
/* initialize Madagascar */
sf_init(argc,argv);
/* initialize OpenMP support */
#ifdef _OPENMP
omp_init();
#endif
if(!sf_getbool("verb", &verb)) verb=false;
/* verbosity flag */
if(!sf_getbool("adj", &adj)) adj=false;
/* adjoint flag, 0: modeling, 1: migration */
if(!sf_getbool("pas", &pas)) pas=false;
/* passive flag, 0: exploding reflector rtm, 1: passive seismic imaging */
if(!sf_getbool("abc",&abc)) abc = false;
/* absorbing boundary condition */
if(!sf_getint("snap", &snap)) snap=0;
/* wavefield snapshot flag */
if(!sf_getint("depth", &depth)) depth=0;
/* surface */
/* setup I/O files */
in = sf_input("in");
out = sf_output("out");
vel = sf_input("velocity");
/* velocity model */
/* Dimensions */
if(!sf_histint (vel, "n1", &nz)) sf_error("No n1= in velocity");
if(!sf_histint (vel, "n2", &nx)) sf_error("No n2= in velocity");
if(!sf_histfloat(vel, "o1", &oz)) sf_error("No o1= in velocity");
if(!sf_histfloat(vel, "o2", &ox)) sf_error("No o2= in velocity");
if(!sf_histfloat(vel, "d1", &dz)) sf_error("No d1= in velocity");
if(!sf_histfloat(vel, "d2", &dx)) sf_error("No d2= in velocity");
if(adj){ /* migration */
if(!sf_histint(in, "n1", &nt)) sf_error("No n1= in data");
if(!sf_histfloat(in, "d1", &dt)) sf_error("No d1= in data");
if(!sf_histint(in, "n2", &n2) || n2!=nx) sf_error("Need n2=%d in data", nx);
sf_putint (out, "n1", nz);
sf_putfloat (out, "o1", oz);
sf_putfloat (out, "d1", dz);
sf_putstring(out, "label1", "Depth");
sf_putstring(out, "unit1" , "km");
sf_putint (out, "n2", nx);
sf_putfloat (out, "o2", ox);
sf_putfloat (out, "d2", dx);
sf_putstring(out, "label2", "Distance");
sf_putstring(out, "unit2" , "km");
if (pas) {
sf_putint (out, "n3", nt);
sf_putfloat (out, "d3", dt);
sf_putfloat (out, "o3", 0.0f);
sf_putstring(out, "label3", "Time");
sf_putstring(out, "unit3" , "s");
}
}else{ /* modeling */
if(!sf_getint("nt", &nt)) sf_error("Need nt=");
if(!sf_getfloat("dt", &dt)) sf_error("Need dt=");
sf_putint (out, "n1", nt);
sf_putfloat (out, "d1", dt);
sf_putfloat (out, "o1", 0.0);
sf_putstring(out, "label1", "Time");
sf_putstring(out, "unit1" , "s");
sf_putint (out, "n2", nx);
sf_putfloat (out, "o2", ox);
sf_putfloat (out, "d2", dx);
sf_putstring(out, "label2", "Distance");
sf_putstring(out, "unit2" , "km");
if (pas) {
sf_putint (out, "n3", 1);
}
}
/* dimension of padded boundary */
if(!sf_getint("nb", &nb) || nb<NOP) nb = NOP;
if(!sf_getfloat("cb", &cb)) cb = 0.0f;
nxpad = nx+2*nb;
nzpad = nz+2*nb;
nzxpad = nzpad*nxpad;
depth = depth+nb;
/* set Laplacian coefficients */
idz2 = 1.0f/(dz*dz);
idx2 = 1.0f/(dx*dx);
/* wavefield snapshot */
if(snap){
wave = sf_output("wave");
sf_putint(wave, "n1", nzpad);
sf_putfloat(wave, "d1", dz);
sf_putfloat(wave, "o1", oz-nb*dz);
sf_putint(wave, "n2", nxpad);
sf_putfloat(wave, "d2", dx);
sf_putfloat(wave, "o2", ox-nb*dx);
sf_putint(wave, "n3", 1+(nt-1)/snap);
if(adj){
sf_putfloat(wave, "d3", -snap*dt);
sf_putfloat(wave, "o3", (nt-1)*dt);
}else{
sf_putfloat(wave, "d3", snap*dt);
sf_putfloat(wave, "o3", 0.0f);
}
}
/* allocate arrays */
vv = sf_floatalloc2(nz, nx);
dd = sf_floatalloc2(nt, nx);
vvpad = sf_floatalloc2(nzpad, nxpad);
u0 = sf_floatalloc2(nzpad, nxpad);
u1 = sf_floatalloc2(nzpad, nxpad);
u2 = sf_floatalloc2(nzpad, nxpad);
if (pas) {
mm = NULL;
ww = sf_floatalloc3(nz, nx, nt);
} else {
mm = sf_floatalloc2(nz, nx);
ww = NULL;
}
/* read velocity */
sf_floatread(vv[0], nz*nx, vel);
/* pad boundary */
dt2 = dt*dt;
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
vvpad[ix+nb][iz+nb] = vv[ix][iz]*vv[ix][iz]*dt2;
for (ix=0; ix<nxpad; ix++){
for (iz=0; iz<nb; iz++){
vvpad[ix][ iz ] = vvpad[ix][ nb ];
vvpad[ix][nzpad-iz-1] = vvpad[ix][nzpad-nb-1];
}
}
for (ix=0; ix<nb; ix++){
for (iz=0; iz<nzpad; iz++){
vvpad[ ix ][iz]=vvpad[ nb ][iz];
vvpad[nxpad-ix-1][iz]=vvpad[nxpad-nb-1][iz];
}
}
memset(u0[0], 0.0f, nzxpad*sizeof(float));
memset(u1[0], 0.0f, nzxpad*sizeof(float));
memset(u2[0], 0.0f, nzxpad*sizeof(float));
/* absorbing boundary condition */
if (abc) {
if (verb) sf_warning("absorbing boundary condition");
abc_init(nzpad,nxpad,nzpad,nxpad,nb,nb,nb,nb,cb,cb,cb,cb);
}
if(adj){ /* migration */
/* read data */
sf_floatread(dd[0], nt*nx, in);
for (it=nt-1; it>-1; it--){
if (verb) sf_warning("Migration: %d/%d;", it, 0);
/* time stepping */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=NOP; ix<nxpad-NOP; ix++){
for (iz=NOP; iz<nzpad-NOP; iz++){
u2[ix][iz] = LapT(u1,ix,iz,idx2,idz2,vvpad) + 2.0f*u1[ix][iz] - u0[ix][iz];
}
}
/* rotate pointers */
tmp=u0; u0=u1; u1=u2; u2=tmp;
if (abc) abc_apply(u1[0]);
if (abc) abc_apply(u0[0]);
/* inject data */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix)
#endif
for (ix=nb; ix<nb+nx; ix++)
u1[ix][depth] += dd[ix-nb][it];
if (pas) {
/* image source */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
ww[it][ix][iz] = u1[ix+nb][iz+nb];
}
if (snap && it%snap==0) sf_floatwrite(u1[0], nzxpad, wave);
}
if (verb) sf_warning(".");
if (!pas) {
/* output image */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
mm[ix][iz] = u1[ix+nb][iz+nb];
sf_floatwrite(mm[0], nz*nx, out);
} else {
/* output source */
sf_floatwrite(ww[0][0], nz*nx*nt, out);
}
}else{/* modeling */
if (pas) {
/* read source */
sf_floatread(ww[0][0], nz*nx*nt, in);
} else {
/* read image */
sf_floatread(mm[0], nz*nx, in);
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
u1[ix+nb][iz+nb] = mm[ix][iz];
}
for (it=0; it<nt; it++){
if (verb) sf_warning("Modeling: %d/%d;", it, nt-1);
if(snap && it%snap==0) sf_floatwrite(u1[0], nzxpad, wave);
if (pas){
/* inject source */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
u1[ix+nb][iz+nb] += ww[it][ix][iz];
}
/* record data */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix)
#endif
for (ix=nb; ix<nb+nx; ix++)
dd[ix-nb][it] = u1[ix][depth];
if (abc) abc_apply(u0[0]);
if (abc) abc_apply(u1[0]);
/* time stepping */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=NOP; ix<nxpad-NOP; ix++){
for (iz=NOP; iz<nzpad-NOP; iz++){
u2[ix][iz] = Lap (u1,ix,iz,idx2,idz2,vvpad) + 2.0f*u1[ix][iz] - u0[ix][iz];
}
}
/* rotate pointers */
tmp=u0; u0=u1; u1=u2; u2=tmp;
}
if (verb) sf_warning(".");
/* output data */
sf_floatwrite(dd[0], nt*nx, out);
}
if(pas) {
free(**ww); free(*ww); free(ww);
} else {
free(*mm); free(mm);
}
if (abc) abc_close();
free(*vvpad); free(vvpad); free(*vv); free(vv);
free(*dd); free(dd);
free(*u0); free(u0); free(*u1); free(u1); free(*u2); free(u2);
exit (0);
}
int psp3(float **wvfld, float **wvfld1, float **dat, float **dat1, float *img, float *vel, pspar par)
/*< pseudo-spectral back propagation of two receiver wavefields >*/
{
/*survey parameters*/
int nx, nz;
float dx, dz;
int n_srcs;
int *spx, *spz;
int gpz, gpx, gpl;
int gpz_v, gpx_v, gpl_v;
int snap;
/*fft related*/
bool cmplx;
int pad1;
/*absorbing boundary*/
bool abc;
int nbt, nbb, nbl, nbr;
float ct,cb,cl,cr;
/*source parameters*/
int src; /*source type*/
int nt;
float dt,*f0,*t0,*A;
/*misc*/
bool verb, ps;
float vref;
int nx1, nz1; /*domain of interest*/
int it,iz,ik,ix,i,j; /* index variables */
int nk,nzx,nz2,nx2,nzx2,nkz,nth;
int it1, it2, its;
float dkx,dkz,kx0,kz0,vref2,kx,kz,k;
float c, old;
/*wave prop arrays*/
float *vv;
sf_complex *cwave,*cwavem;
float *wave,*curr,*curr1,*prev,*prev1,*lapl;
/*passing the parameters*/
nx = par->nx;
nz = par->nz;
dx = par->dx;
dz = par->dz;
n_srcs= par->n_srcs;
spx = par->spx;
spz = par->spz;
gpz = par->gpz;
gpx = par->gpx;
gpl = par->gpl;
gpz_v = par->gpz_v;
gpx_v = par->gpx_v;
gpl_v = par->gpl_v;
snap = par->snap;
cmplx = par->cmplx;
pad1 = par->pad1;
abc = par->abc;
nbt = par->nbt;
nbb = par->nbb;
nbl = par->nbl;
nbr = par->nbr;
ct = par->ct;
cb = par->cb;
cl = par->cl;
cr = par->cr;
src = par->src;
nt = par->nt;
dt = par->dt;
f0 = par->f0;
t0 = par->t0;
A = par->A;
verb = par->verb;
ps = par->ps;
vref = par->vref;
#ifdef _OPENMP
#pragma omp parallel
{
nth = omp_get_num_threads();
}
#else
nth = 1;
#endif
if (verb) sf_warning(">>>> Using %d threads <<<<<", nth);
nz1 = nz-nbt-nbb;
nx1 = nx-nbl-nbr;
nk = fft2_init(cmplx,pad1,nz,nx,&nz2,&nx2);
nzx = nz*nx;
nzx2 = nz2*nx2;
dkz = 1./(nz2*dz); kz0 = (cmplx)? -0.5/dz:0.;
dkx = 1./(nx2*dx); kx0 = -0.5/dx;
nkz = (cmplx)? nz2:(nz2/2+1);
if(nk!=nx2*nkz) sf_error("wavenumber dimension mismatch!");
sf_warning("dkz=%f,dkx=%f,kz0=%f,kx0=%f",dkz,dkx,kz0,kx0);
sf_warning("nk=%d,nkz=%d,nz2=%d,nx2=%d",nk,nkz,nz2,nx2);
if(abc)
abc_init(nz,nx,nz2,nx2,nbt,nbb,nbl,nbr,ct,cb,cl,cr);
/* allocate and read/initialize arrays */
vv = sf_floatalloc(nzx);
lapl = sf_floatalloc(nk);
wave = sf_floatalloc(nzx2);
curr = sf_floatalloc(nzx2);
curr1 = sf_floatalloc(nzx2);
prev = sf_floatalloc(nzx2);
prev1 = sf_floatalloc(nzx2);
cwave = sf_complexalloc(nk);
cwavem = sf_complexalloc(nk);
for (iz=0; iz < nzx; iz++) {
vv[iz] = vel[iz]*vel[iz]*dt*dt;
}
vref *= dt;
vref2 = vref*vref;
for (iz=0; iz < nzx2; iz++) {
curr[iz] = 0.;
curr1[iz] = 0.;
prev[iz] = 0.;
prev1[iz] = 0.;
}
for (iz=0; iz < nz1*nx1; iz++) {
img[iz] = 0.;
}
/* constructing the pseudo-analytical op */
for (ix=0; ix < nx2; ix++) {
kx = kx0+ix*dkx;
for (iz=0; iz < nkz; iz++) {
kz = kz0+iz*dkz;
k = 2*SF_PI*hypot(kx,kz);
if (ps) lapl[iz+ix*nkz] = -k*k;
else lapl[iz+ix*nkz] = 2.*(cos(vref*k)-1.)/vref2;
}
}
/* step backward in time */
it1 = nt-1;
it2 = -1;
its = -1;
/* MAIN LOOP */
for (it=it1; it!=it2; it+=its) {
if(verb) sf_warning("it=%d/%d;",it,nt);
/* first receiver wavefield */
/* matrix multiplication */
fft2(curr,cwave);
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*lapl[ik];
#else
cwavem[ik] = sf_cmul(cwave[ik],lapl[ik]);
#endif
}
ifft2(wave,cwavem);
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j,old,c)
#endif
for (ix = 0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
i = iz+ix*nz; /* original grid */
j = iz+ix*nz2; /* padded grid */
old = c = curr[j];
c += c - prev[j];
prev[j] = old;
c += wave[j]*vv[i];
curr[j] = c;
}
}
/* inject data */
if (NULL!=dat) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix)
#endif
for (ix = 0; ix < gpl; ix++) {
curr[gpz+(ix+gpx)*nz2] += vv[gpz+(ix+gpx)*nz]*dat[ix][it];
}
}
/*apply abc*/
if (abc) {
abc_apply(curr);
abc_apply(prev);
}
/* second receiver wavefield */
/* matrix multiplication */
fft2(curr1,cwave);
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*lapl[ik];
#else
cwavem[ik] = sf_cmul(cwave[ik],lapl[ik]);
#endif
}
ifft2(wave,cwavem);
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j,old,c)
#endif
for (ix = 0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
i = iz+ix*nz; /* original grid */
j = iz+ix*nz2; /* padded grid */
old = c = curr1[j];
c += c - prev1[j];
prev1[j] = old;
c += wave[j]*vv[i];
curr1[j] = c;
}
}
/* inject data */
if (NULL!=dat1) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix)
#endif
for (ix = 0; ix < gpl; ix++) {
curr1[gpz+(ix+gpx)*nz2] += vv[gpz+(ix+gpx)*nz]*dat1[ix][it];
}
}
/*apply abc*/
if (abc) {
abc_apply(curr1);
abc_apply(prev1);
}
/* cross-correlation imaging condition */
if (snap > 0 && it%snap==0) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j)
#endif
for (ix = 0; ix < nx1; ix++) {
for (iz = 0; iz < nz1; iz++) {
i = iz + nz1*ix;
j = iz+nbt + (ix+nbl)*nz2; /* padded grid */
img[i] += curr[j]*curr1[j]; //!!!IMPORTANT!!!
}
}
}
/* save wavefield */
if (snap > 0 && it%snap==0) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j)
#endif
for (ix=0; ix<nx1; ix++) {
for (iz=0; iz<nz1; iz++) {
i = iz + nz1*ix;
j = iz+nbt + (ix+nbl)*nz2; /* padded grid */
wvfld[it/snap][i] = curr[j];
wvfld1[it/snap][i] = curr1[j];
}
}
}
}
if(verb) sf_warning(".");
/*free up memory*/
fft2_finalize();
if (abc) abc_close();
free(vv);
free(lapl);
free(wave);
free(curr);
free(curr1);
free(prev);
free(prev1);
free(cwave);
free(cwavem);
return 0;
}
int psp4(float **wvfld, float **wvfld0, float **dat, float **dat_v, float *vel, pspar par)
/*< pseudo-spectral wave extrapolation using wavefield injection >*/
{
/*survey parameters*/
int nx, nz;
float dx, dz;
int n_srcs;
int *spx, *spz;
int gpz, gpx, gpl;
int gpz_v, gpx_v, gpl_v;
int snap;
/*fft related*/
bool cmplx;
int pad1;
/*absorbing boundary*/
bool abc;
int nbt, nbb, nbl, nbr;
float ct,cb,cl,cr;
/*source parameters*/
int src; /*source type*/
int nt;
float dt,*f0,*t0,*A;
/*misc*/
bool verb, ps;
float vref;
int nx1, nz1; /*domain of interest*/
int it,iz,ik,ix,i,j; /* index variables */
int nk,nzx,nz2,nx2,nzx2,nkz,nth;
int it1, it2, its;
float dkx,dkz,kx0,kz0,vref2,kx,kz,k,t;
float c, old;
/*wave prop arrays*/
float *vv;
sf_complex *cwave,*cwavem;
float *wave,*curr,*prev,*lapl;
/*source*/
float **rick;
float freq;
int fft_size;
/*passing the parameters*/
nx = par->nx;
nz = par->nz;
dx = par->dx;
dz = par->dz;
n_srcs= par->n_srcs;
spx = par->spx;
spz = par->spz;
gpz = par->gpz;
gpx = par->gpx;
gpl = par->gpl;
gpz_v = par->gpz_v;
gpx_v = par->gpx_v;
gpl_v = par->gpl_v;
snap = par->snap;
cmplx = par->cmplx;
pad1 = par->pad1;
abc = par->abc;
nbt = par->nbt;
nbb = par->nbb;
nbl = par->nbl;
nbr = par->nbr;
ct = par->ct;
cb = par->cb;
cl = par->cl;
cr = par->cr;
src = par->src;
nt = par->nt;
dt = par->dt;
f0 = par->f0;
t0 = par->t0;
A = par->A;
verb = par->verb;
ps = par->ps;
vref = par->vref;
#ifdef _OPENMP
#pragma omp parallel
{
nth = omp_get_num_threads();
}
#else
nth = 1;
#endif
if (verb) sf_warning(">>>> Using %d threads <<<<<", nth);
nz1 = nz-nbt-nbb;
nx1 = nx-nbl-nbr;
nk = fft2_init(cmplx,pad1,nz,nx,&nz2,&nx2);
nzx = nz*nx;
nzx2 = nz2*nx2;
dkz = 1./(nz2*dz); kz0 = (cmplx)? -0.5/dz:0.;
dkx = 1./(nx2*dx); kx0 = -0.5/dx;
nkz = (cmplx)? nz2:(nz2/2+1);
if(nk!=nx2*nkz) sf_error("wavenumber dimension mismatch!");
sf_warning("dkz=%f,dkx=%f,kz0=%f,kx0=%f",dkz,dkx,kz0,kx0);
sf_warning("nk=%d,nkz=%d,nz2=%d,nx2=%d",nk,nkz,nz2,nx2);
if(abc)
abc_init(nz,nx,nz2,nx2,nbt,nbb,nbl,nbr,ct,cb,cl,cr);
/* allocate and read/initialize arrays */
vv = sf_floatalloc(nzx);
lapl = sf_floatalloc(nk);
wave = sf_floatalloc(nzx2);
curr = sf_floatalloc(nzx2);
prev = sf_floatalloc(nzx2);
cwave = sf_complexalloc(nk);
cwavem = sf_complexalloc(nk);
if (src==0) {
rick = sf_floatalloc2(nt,n_srcs);
for (i=0; i<n_srcs; i++) {
for (it=0; it<nt; it++) {
rick[i][it] = 0.f;
}
rick[i][(int)(t0[i]/dt)] = A[i]; /*time delay*/
freq = f0[i]*dt; /*peak frequency*/
fft_size = 2*kiss_fft_next_fast_size((nt+1)/2);
ricker_init(fft_size, freq, 0);
sf_freqfilt(nt,rick[i]);
ricker_close();
}
} else rick = NULL;
for (iz=0; iz < nzx; iz++) {
vv[iz] = vel[iz]*vel[iz]*dt*dt;
}
vref *= dt;
vref2 = vref*vref;
for (iz=0; iz < nzx2; iz++) {
curr[iz] = 0.;
prev[iz] = 0.;
}
/* constructing the pseudo-analytical op */
for (ix=0; ix < nx2; ix++) {
kx = kx0+ix*dkx;
for (iz=0; iz < nkz; iz++) {
kz = kz0+iz*dkz;
k = 2*SF_PI*hypot(kx,kz);
if (ps) lapl[iz+ix*nkz] = -k*k;
else lapl[iz+ix*nkz] = 2.*(cos(vref*k)-1.)/vref2;
}
}
/* modeling */
/* step forward in time */
it1 = 0;
it2 = nt;
its = +1;
/* MAIN LOOP */
for (it=it1; it!=it2; it+=its) {
if(verb) sf_warning("it=%d/%d;",it,nt);
/* matrix multiplication */
fft2(curr,cwave);
for (ik = 0; ik < nk; ik++) {
#ifdef SF_HAS_COMPLEX_H
cwavem[ik] = cwave[ik]*lapl[ik];
#else
cwavem[ik] = sf_cmul(cwave[ik],lapl[ik]);
#endif
}
ifft2(wave,cwavem);
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j,old,c)
#endif
for (ix = 0; ix < nx; ix++) {
for (iz=0; iz < nz; iz++) {
i = iz+ix*nz; /* original grid */
j = iz+ix*nz2; /* padded grid */
old = c = curr[j];
c += c - prev[j];
prev[j] = old;
c += wave[j]*vv[i];
curr[j] = c;
}
}
if (NULL!=wvfld0) { /* wavefield injection */
if (snap > 0 && it%snap==0) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j,ik)
#endif
for (ix=0; ix<nx1; ix++) {
for (iz=0; iz<nz1; iz++) {
i = iz + nz1*ix;
j = iz+nbt + (ix+nbl)*nz2; /* padded grid */
ik = iz+nbt + (ix+nbl)*nz; /* padded grid */
curr[j] += vv[ik]*wvfld0[it/snap][i];
}
}
}
} else { /* source injection */
t = it*dt;
for (i=0; i<n_srcs; i++) {
for(ix=-1;ix<=1;ix++) {
for(iz=-1;iz<=1;iz++) {
ik = spz[i]+iz+nz*(spx[i]+ix);
j = spz[i]+iz+nz2*(spx[i]+ix);
if (src==0) {
curr[j] += vv[ik]*rick[i][it]/(abs(ix)+abs(iz)+1);
} else {
curr[j] += vv[ik]*Ricker(t, f0[i], t0[i], A[i])/(abs(ix)+abs(iz)+1);
}
}
}
}
}
/*apply abc*/
if (abc) {
abc_apply(curr);
abc_apply(prev);
}
/* record data */
if (NULL!=dat) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix)
#endif
for (ix = 0; ix < gpl; ix++) {
dat[ix][it] = curr[gpz+(ix+gpx)*nz2];
}
}
if (NULL!=dat_v) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(iz)
#endif
for (iz = 0; iz < gpl_v; iz++) {
dat_v[iz][it] = curr[gpz_v+iz+(gpx_v)*nz2];
}
}
/* save wavefield */
if (snap > 0 && it%snap==0) {
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix,iz,i,j)
#endif
for (ix=0; ix<nx1; ix++) {
for (iz=0; iz<nz1; iz++) {
i = iz + nz1*ix;
j = iz+nbt + (ix+nbl)*nz2; /* padded grid */
wvfld[it/snap][i] = curr[j];
}
}
}
}
if(verb) sf_warning(".");
/*free up memory*/
fft2_finalize();
if (abc) abc_close();
free(vv);
free(lapl);
free(wave);
free(curr);
free(prev);
free(cwave);
free(cwavem);
return 0;
}
int main(int argc , char * argv[]){
struct abctune * tunes, * tune;
struct abcsym * sym;
int n_tunes = 1, debug_flag=1, i;
char info_type;
abc_init((void *(*)(int sz)) malloc,
free,
0,
sizeof (struct SYMBOL) - sizeof (struct abcsym),
1);
if(argc == 2) { tunes = abc_parse(fslurp(argv[1])) ; }
else { tunes = abc_parse(fslurp("x.abc")) ; }
/* short lengthx[4]; */
/* printf("\n>>>>>>>>>>>>>%d\n",sizeof lengthx[0]); */
printf("{"); // begin of structure
printf("deco_tb => {"); // begin of deco_tb
int o=0, first_deco=1;
for(o=0; o<128; o++) {
if (deco_tb[o]) {
if (first_deco) { first_deco = 0; }
else { printf(","); }
printf("%d=>\"%s\"", o, deco_tb[o]);
}
}
printf("},"); // end of deco_tb
if (debug_flag) printf("\n");
printf("tunes => {"); // begin of tunes
if (debug_flag) printf("\n");
for (tune = tunes; tune != 0; tune = tune->next){
printf("%d => {", n_tunes); // begin of tune
if (debug_flag) printf("\n");
printf("abc_vers=>%d,",tune->abc_vers);
if (tune->client_data)
printf("client_data=>%s,",(char *)tune->client_data);
else
printf("client_data=>\"\",");
printf("micro_tb=>[");
for (i=0; i<MAXMICRO; i++) {
if (i>0) printf(",");
printf("%d",tune->micro_tb[i]);
}
printf("],");
if (debug_flag) printf("\n");
printf("symbols=>["); // begin of symbols
for (sym = tune->first_sym; sym != 0; sym = sym->next){
printf("{"); // begin of symbol
printf("type=>%d," ,sym->type);
printf("state=>%d," ,sym->state);
printf("colnum=>%d," ,sym->colnum);
printf("flags=>%d," ,sym->flags);
printf("linenum=>%d," ,sym->linenum);
printf("text=>\"%s\"," ,escape_string(sym->text));
printf("comment=>\"%s\"," ,escape_string(sym->comment));
printf("info=>{"); // begin of info
if (sym->type == 1) { // symbols of type 1 (Info)
info_type = sym->text[0];
switch (info_type) {
case 'K': // Key
printf("sf=>%d," ,sym->u.key.sf);
printf("empty=>%d," ,sym->u.key.empty);
printf("exp=>%d," ,sym->u.key.exp);
printf("mode=>%d," ,sym->u.key.mode);
printf("nacc=>%d," ,sym->u.key.nacc);
printf("octave=>%d," ,sym->u.key.octave);
printf("pits=>[");
for (i=0; i<8; i++) {
if (i>0) printf(",");
printf("%d",sym->u.key.pits[i]);
}
printf("],");
printf("accs=>[");
for (i=0; i<8; i++) {
if (i>0) printf(",");
printf("%d",sym->u.key.accs[i]);
}
printf("]");
break;
case 'L': // Length
printf("base_length=>%d",sym->u.length.base_length);
break;
case 'M': // Meter
printf("wmeasure=>%d," ,sym->u.meter.wmeasure);
printf("nmeter=>%d," ,sym->u.meter.nmeter);
printf("expdur=>%d," ,sym->u.meter.expdur);
printf("meter=>[");
for (i=0; i<sym->u.meter.nmeter; i++){
if (i>0) printf(",");
printf("{");
printf("top=>\"%s\"," ,escape_string(sym->u.meter.meter[i].top));
printf("bot=>\"%s\"" ,escape_string(sym->u.meter.meter[i].bot));
printf("}");
}
printf("]");
break;
case 'Q': // Tempo
printf("str1=>\"%s\"," ,escape_string(sym->u.tempo.str1));
printf("length=>[");
for (i=0; i<4; i++) {
if (i>0) printf(",");
printf("%d",sym->u.tempo.length[i]);
/* printf("\n\n\n\n\tlength:%d\n\n\n\n",sym->u.tempo.length[i]); */
}
printf("],");
/* printf("\n\n\n\n\tvalue:%s\n\n\n\n",sym->u.tempo.value); */
printf("value=>\"%s\"," ,escape_string(sym->u.tempo.value));
printf("str2=>\"%s\"" ,escape_string(sym->u.tempo.str2));
break;
case 'V': // Voice
/* printf("\n\n\n\n\tvoice_id:%s\n\n\n\n",sym->u.voice.id); */
printf("id=>\"%s\"," ,escape_string(sym->u.voice.id));
printf("fname=>\"%s\"," ,escape_string(sym->u.voice.fname));
printf("nname=>\"%s\"," ,escape_string(sym->u.voice.nname));
printf("voice=>%d," ,sym->u.voice.voice);
printf("octave=>%d," ,sym->u.voice.octave);
printf("scale=>%f," ,sym->u.voice.scale);
printf("merge=>%d," ,sym->u.voice.merge);
printf("stem=>%d," ,sym->u.voice.stem);
printf("gstem=>%d," ,sym->u.voice.gstem);
printf("dyn=>%d," ,sym->u.voice.dyn);
printf("lyrics=>%d," ,sym->u.voice.lyrics);
printf("gchord=>%d" ,sym->u.voice.gchord);
break;
case 'U': // Symbols Redefition
printf("symbol=>%d," ,sym->u.user.symbol);
printf("value=>%d" ,sym->u.user.value);
break;
}
} // end of type 1
if (sym->type == 3) { // symbols of type 3 (Clef)
printf("name=>\"%s\",",escape_string(sym->u.clef.name));
printf("staffscale=>%f,",sym->u.clef.staffscale);
printf("stafflines=>%d,",sym->u.clef.stafflines);
printf("type=>%d,",sym->u.clef.type);
printf("line=>%d,",sym->u.clef.line);
printf("octave=>%d,",sym->u.clef.octave);
printf("transpose=>%d,",sym->u.clef.transpose);
printf("invis=>%d,",sym->u.clef.invis);
printf("check_pitch=>%d",sym->u.clef.check_pitch);
} // end of type 3
if (sym->type == 4 || sym->type == 5) { // symbols of type 4 and 5 (Note, Rest)
printf("pits=>[");
for (i=0; i<MAXHD; i++) {
if (i>0) printf(",");
printf("%d",sym->u.note.pits[i]);
}
printf("],");
printf("lens=>[");
for (i=0; i<MAXHD; i++) {
if (i>0) printf(",");
printf("%d",sym->u.note.lens[i]);
}
printf("],");
printf("accs=>[");
for (i=0; i<MAXHD; i++) {
if (i>0) printf(",");
printf("%d",sym->u.note.accs[i]);
}
printf("],");
printf("sl1=>[");
for (i=0; i<MAXHD; i++) {
if (i>0) printf(",");
printf("%d",sym->u.note.sl1[i]);
}
printf("],");
printf("sl2=>[");
for (i=0; i<MAXHD; i++) {
if (i>0) printf(",");
printf("%d",sym->u.note.sl2[i]);
}
printf("],");
printf("ti1=>[");
for (i=0; i<MAXHD; i++) {
if (i>0) printf(",");
printf("%d",sym->u.note.ti1[i]);
}
printf("],");
printf("decs=>[");
for (i=0; i<MAXHD; i++) {
if (i>0) printf(",");
printf("%d",sym->u.note.decs[i]);
}
printf("],");
printf("chlen=>%d,",sym->u.note.chlen);
printf("nhd=>%d,",sym->u.note.nhd);
printf("slur_st=>%d,",sym->u.note.slur_st);
printf("slur_end=>%d,",sym->u.note.slur_end);
printf("brhythm=>%d,",sym->u.note.brhythm);
printf("dc=>{");
printf("n=>%d," ,sym->u.note.dc.n);
printf("h=>%d," ,sym->u.note.dc.h);
printf("s=>%d," ,sym->u.note.dc.s);
printf("t=>[");
for (i=0; i<MAXDC; i++) {
if (i>0) printf(",");
printf("%d",sym->u.note.dc.t[i]);
}
printf("]");
printf("}"); // end of dc
} // end of type 4, 5
if (sym->type == 6 || sym->type == 8 || sym->type == 9) { // symbols of type 6, 8, 9 (Bar, Multi-measure Rest (mrest) and Measure Repeat (mrep))
printf("type=>%d,",sym->u.bar.type);
printf("repeat_bar=>%d,",sym->u.bar.repeat_bar);
printf("len=>%d,",sym->u.bar.len);
printf("dotted=>%d,",sym->u.bar.dotted);
printf("dc=>{");
printf("n=>%d," ,sym->u.bar.dc.n);
printf("h=>%d," ,sym->u.bar.dc.h);
printf("s=>%d," ,sym->u.bar.dc.s);
printf("t=>[");
for (i=0; i<MAXDC; i++) {
if (i>0) printf(",");
printf("%d",sym->u.bar.dc.t[i]);
}
printf("]");
printf("}");
} // end of type 6, 8, 9
if (sym->type == 7) { // symbols of type 7 (End of Line (eoln))
printf("type=>%d",sym->u.eoln.type);
} // end of type 7
if (sym->type == 10) { // symbols of type 10 (Voice Overlay (v_over))
printf("type=>%d,",sym->u.v_over.type);
printf("voice=>%d",sym->u.v_over.voice);
} // end of type 10
if (sym->type == 11) { // symbols of type 11 (Tuplet)
printf("p_plet=>%d,",sym->u.tuplet.p_plet);
printf("q_plet=>%d,",sym->u.tuplet.q_plet);
printf("r_plet=>%d",sym->u.tuplet.r_plet);
} // end of type 11
printf("}"); // end of info
printf("}"); // end of symbol
if (sym->next != 0) printf(",");
if (debug_flag) printf("\n");
}
printf("]"); // end of symbols
printf("}"); // end of tune
if (tune->next != 0) printf(",");
n_tunes++;
}
printf("}"); // end of tunes
printf("}"); // end of structure
return 0;
}
