int main(int argc, char **argv)
{
modPar mod;
recPar rec;
srcPar src;
shotPar shot;
rayPar ray;
float *velocity, *slowness, *smooth, *trueslow, **inter;
double t0, t1, t2, tinit, tray, tio;
size_t size;
int nw, n1, ix, iz, ir, ixshot, izshot;
int nt, ntfft, nfreq, ig;
int irec, sbox, ipos, nrx, nrz, nr;
fcoord coordsx, coordgx, Time;
icoord grid, isrc;
float Jr, *ampl, *time, *ttime, *ttime_p, cp_average, *wavelet, dw, dt;
float dxrcv, dzrcv, rdelay, tr, dt_tmp;
segy hdr;
char filetime[1024], fileamp[1024], *method, *file_rcvtime, *file_src;
size_t nwrite, nread;
int verbose;
complex *cmute, *cwav;
FILE *fpt, *fpa, *fpwav, *fprcv;
t0= wallclock_time();
initargs(argc,argv);
requestdoc(0);
if(!getparint("verbose",&verbose)) verbose=0;
if(!getparint("sbox", &sbox)) sbox = 1;
if(!getparstring("method", &method)) method="jesper";
if (!getparfloat("rec_delay",&rdelay)) rdelay=0.0;
getParameters(&mod, &rec, &src, &shot, &ray, verbose);
/* read file_src if file_rcvtime is defined */
if (!getparstring("file_rcvtime",&file_rcvtime)) file_rcvtime=NULL;
if (file_rcvtime != NULL) {
if (!getparstring("file_src",&file_src)) file_src=NULL;
if (!getparfloat("dt",&dt)) dt=0.004;
if (file_src != NULL ) {
fpwav = fopen( file_src, "r" );
assert( fpwav != NULL);
nread = fread( &hdr, 1, TRCBYTES, fpwav );
assert(nread == TRCBYTES);
ntfft = optncr(MAX(hdr.ns, rec.nt));
wavelet = (float *)calloc(ntfft,sizeof(float));
/* read first trace */
nread = fread(wavelet, sizeof(float), hdr.ns, fpwav);
assert (nread == hdr.ns);
fclose(fpwav);
}
else {
ntfft = optncr(rec.nt);
wavelet = (float *)calloc(ntfft,sizeof(float));
wavelet[0] = 1.0;
}
nfreq = ntfft/2+1;
cwav = (complex *)calloc(nfreq,sizeof(complex));
cmute = (complex *)calloc(nfreq,sizeof(complex));
rc1fft(wavelet,cwav,ntfft,-1);
dw = 2*M_PI/(ntfft*dt);
}
/* allocate arrays for model parameters: the different schemes use different arrays */
n1 = mod.nz;
if(!strcmp(method,"fd")) nw = 0;
else nw = ray.smoothwindow;
velocity = (float *)calloc(mod.nx*mod.nz,sizeof(float));
slowness = (float *)calloc((mod.nx+2*nw)*(mod.nz+2*nw),sizeof(float));
trueslow = (float *)calloc(mod.nx*mod.nz,sizeof(float));
if(!strcmp(method,"fd")) {
ttime = (float *)calloc(mod.nx*mod.nz,sizeof(float));
}
/* read velocity and density files */
readModel(mod, velocity, slowness, nw);
/* allocate arrays for wavefield and receiver arrays */
size = shot.n*rec.n;
time = (float *)calloc(size,sizeof(float));
ampl = (float *)calloc(size,sizeof(float));
/* Sinking source and receiver arrays:
If P-velocity==0 the source and receiver
postions are placed deeper until the P-velocity changes.
Setting the option rec.sinkvel only sinks the receiver position
(not the source) and uses the velocity
of the first receiver to sink through to the next layer. */
/* sink receivers to value different than sinkvel */
for (ir=0; ir<rec.n; ir++) {
iz = rec.z[ir];
ix = rec.x[ir];
while(velocity[(ix)*n1+iz] == rec.sinkvel) iz++;
rec.z[ir]=iz+rec.sinkdepth;
rec.zr[ir]=rec.zr[ir]+(rec.z[ir]-iz)*mod.dz;
// rec.zr[ir]=rec.z[ir]*mod.dz;
if (verbose>3) vmess("receiver position %d at grid[ix=%d, iz=%d] = (x=%f z=%f)", ir, ix, rec.z[ir], rec.xr[ir]+mod.x0, rec.zr[ir]+mod.z0);
}
vmess(" - method for ray-tracing = %s", method);
/*
*/
/* sink sources to value different than zero */
for (izshot=0; izshot<shot.nz; izshot++) {
for (ixshot=0; ixshot<shot.nx; ixshot++) {
iz = shot.z[izshot];
ix = shot.x[ixshot];
while(velocity[(ix)*n1+iz] == 0.0) iz++;
shot.z[izshot]=iz+src.sinkdepth;
}
}
if (verbose>3) writeSrcRecPos(&mod, &rec, &src, &shot);
/* smooth slowness grid */
grid.x = mod.nx;
grid.z = mod.nz;
grid.y = 1;
if ( nw != 0 ) { /* smooth slowness */
smooth = (float *)calloc(grid.x*grid.z,sizeof(float));
applyMovingAverageFilter(slowness, grid, nw, 2, smooth);
memcpy(slowness,smooth,grid.x*grid.z*sizeof(float));
free(smooth);
}
/* prepare output file and headers */
strcpy(filetime, rec.file_rcv);
name_ext(filetime, "_time");
fpt = fopen(filetime, "w");
assert(fpt != NULL);
if (ray.geomspread) {
strcpy(fileamp, rec.file_rcv);
name_ext(fileamp, "_amp");
fpa = fopen(fileamp, "w");
assert(fpa != NULL);
}
if (file_rcvtime != NULL) {
fprcv = fopen(file_rcvtime, "w");
assert(fprcv != NULL);
}
memset(&hdr,0,sizeof(hdr));
hdr.scalco = -1000;
hdr.scalel = -1000;
hdr.trid = 0;
t1=wallclock_time();
tinit = t1-t0;
tray=0.0;
tio=0.0;
/* Outer loop over number of shots */
for (izshot=0; izshot<shot.nz; izshot++) {
for (ixshot=0; ixshot<shot.nx; ixshot++) {
t2=wallclock_time();
if (verbose) {
vmess("Modeling source %d at gridpoints ix=%d iz=%d", (izshot*shot.n)+ixshot, shot.x[ixshot], shot.z[izshot]);
vmess(" which are actual positions x=%.2f z=%.2f", mod.x0+mod.dx*shot.x[ixshot], mod.z0+mod.dz*shot.z[izshot]);
vmess("Receivers at gridpoint x-range ix=%d - %d", rec.x[0], rec.x[rec.n-1]);
vmess(" which are actual positions x=%.2f - %.2f", mod.x0+rec.xr[0], mod.x0+rec.xr[rec.n-1]);
vmess("Receivers at gridpoint z-range iz=%d - %d", rec.z[0], rec.z[rec.n-1]);
vmess(" which are actual positions z=%.2f - %.2f", mod.z0+rec.zr[0], mod.z0+rec.zr[rec.n-1]);
}
coordsx.x = shot.x[ixshot]*mod.dx;
coordsx.z = shot.z[izshot]*mod.dz;
coordsx.y = 0;
t1=wallclock_time();
tio += t1-t2;
if (!strcmp(method,"jesper")) {
#pragma omp parallel for default(shared) \
private (coordgx,irec,Time,Jr)
for (irec=0; irec<rec.n; irec++) {
coordgx.x=rec.xr[irec];
coordgx.z=rec.zr[irec];
coordgx.y = 0;
getWaveParameter(slowness, grid, mod.dx, coordsx, coordgx, ray, &Time, &Jr);
time[((izshot*shot.nx)+ixshot)*rec.n + irec] = Time.x + Time.y + 0.5*Time.z;
ampl[((izshot*shot.nx)+ixshot)*rec.n + irec] = Jr;
if (verbose>4) vmess("JS: shot=%f,%f receiver at %f,%f T0=%f T1=%f T2=%f Jr=%f",coordsx.x, coordsx.z, coordgx.x, coordgx.z, Time.x, Time.y, Time.z, Jr);
}
}
else if(!strcmp(method,"fd")) {
int mzrcv;
isrc.x = shot.x[ixshot];
isrc.y = 0;
isrc.z = shot.z[izshot];
mzrcv = 0;
for (irec = 0; irec < rec.n; irec++) mzrcv = MAX(rec.z[irec], mzrcv);
vidale(ttime,slowness,&isrc,grid,mod.dx,sbox, mzrcv);
for (irec=0; irec<rec.n; irec++) {
coordgx.x=mod.x0+rec.xr[irec];
coordgx.z=mod.z0+rec.zr[irec];
coordgx.y = 0;
ipos = ((izshot*shot.nx)+ixshot)*rec.n + irec;
time[ipos] = ttime[rec.z[irec]*mod.nx+rec.x[irec]];
/* compute average velocity between source and receiver */
nrx = (rec.x[irec]-isrc.x);
nrz = (rec.z[irec]-isrc.z);
nr = abs(nrx) + abs(nrz);
cp_average = 0.0;
for (ir=0; ir<nr; ir++) {
ix = isrc.x + floor((ir*nrx)/nr);
iz = isrc.z + floor((ir*nrz)/nr);
//fprintf(stderr,"ir=%d ix=%d iz=%d velocity=%f\n", ir, ix, iz, velocity[ix*mod.nz+iz]);
cp_average += velocity[ix*mod.nz+iz];
}
cp_average = cp_average/((float)nr);
ampl[ipos] = sqrt(time[ipos]*cp_average);
if (verbose>4) vmess("FD: shot=%f,%f receiver at %f(%d),%f(%d) T=%e V=%f Ampl=%f",coordsx.x, coordsx.z, coordgx.x, rec.x[irec], coordgx.z, rec.z[irec], time[ipos], cp_average, ampl[ipos]);
}
}
t2=wallclock_time();
tray += t2-t1;
hdr.sx = 1000*(mod.x0+mod.dx*shot.x[ixshot]);
hdr.sdepth = 1000*(mod.z0+mod.dz*shot.z[izshot]);
hdr.selev = (int)(-1000.0*(mod.z0+mod.dz*shot.z[izshot]));
hdr.fldr = ((izshot*shot.nx)+ixshot)+1;
hdr.tracl = ((izshot*shot.nx)+ixshot)+1;
hdr.tracf = ((izshot*shot.nx)+ixshot)+1;
hdr.ntr = shot.n;
hdr.dt = (unsigned short)1;
hdr.trwf = shot.n;
hdr.ns = rec.n;
//hdr.d1 = (rec.x[1]-rec.x[0])*mod.dx; // discrete
hdr.d1 = (rec.xr[1]-rec.xr[0]);
hdr.f1 = mod.x0+rec.x[0]*mod.dx;
hdr.d2 = (shot.x[MIN(shot.n-1,1)]-shot.x[0])*mod.dx;
hdr.f2 = mod.x0+shot.x[0]*mod.dx;
dt_tmp = (fabs(hdr.d1*((float)hdr.scalco)));
hdr.dt = (unsigned short)dt_tmp;
nwrite = fwrite( &hdr, 1, TRCBYTES, fpt);
assert(nwrite == TRCBYTES);
nwrite = fwrite( &time[((izshot*shot.nx)+ixshot)*rec.n], sizeof(float), rec.n, fpt);
assert(nwrite == rec.n);
fflush(fpt);
if (ray.geomspread) {
nwrite = fwrite( &hdr, 1, TRCBYTES, fpa);
assert(nwrite == TRCBYTES);
nwrite = fwrite( &l[((izshot*shot.nx)+ixshot)*rec.n], sizeof(float), rec.n, fpa);
assert(nwrite == rec.n);
fflush(fpa);
}
if (file_rcvtime != NULL) {
hdr.ns = rec.nt;
hdr.trwf = rec.n;
hdr.ntr = ((izshot*shot.nx)+ixshot+1)*rec.n;
hdr.dt = dt*1000000;
hdr.d1 = dt;
hdr.f1 = 0.0;
hdr.d2 = (rec.xr[1]-rec.xr[0]);
hdr.f2 = mod.x0+rec.x[0]*mod.dx;
for (irec=0; irec<rec.n; irec++) {
ipos = ((izshot*shot.nx)+ixshot)*rec.n + irec;
hdr.tracf = irec+1;
hdr.tracl = ((izshot*shot.nx)+ixshot*shot.nz)+irec+1;
hdr.gx = 1000*(mod.x0+rec.xr[irec]);
hdr.offset = (rec.xr[irec]-shot.x[ixshot]*mod.dx);
hdr.gelev = (int)(-1000*(mod.z0+rec.zr[irec]));
tr = time[ipos]+rdelay;
for (ig=0; ig<nfreq; ig++) {
cmute[ig].r = (cwav[ig].r*cos(ig*dw*tr-M_PI/4.0)-cwav[ig].i*sin(ig*dw*tr-M_PI/4.0))/(ntfft*ampl[ipos]);
cmute[ig].i = (cwav[ig].i*cos(ig*dw*tr-M_PI/4.0)+cwav[ig].r*sin(ig*dw*tr-M_PI/4.0))/(ntfft*ampl[ipos]);
}
cr1fft(cmute,wavelet,ntfft,-1);
nwrite = fwrite( &hdr, 1, TRCBYTES, fprcv);
nwrite = fwrite( wavelet, sizeof(float), rec.nt, fprcv );
}
}
t1=wallclock_time();
tio += t1-t2;
} /* end of ixshot loop */
} /* end of loop over number of shots */
fclose(fpt);
if (file_rcvtime != NULL) fclose(fprcv);
if (ray.geomspread) fclose(fpa);
t1= wallclock_time();
if (verbose) {
vmess("*******************************************");
vmess("************* runtime info ****************");
vmess("*******************************************");
vmess("Total compute time ray-tracing = %.2f s.", t1-t0);
vmess(" - intializing arrays and model = %.3f", tinit);
vmess(" - ray tracing = %.3f", tray);
vmess(" - writing data to file = %.3f", tio);
}
/* free arrays */
initargs(argc,argv); /* this will free the arg arrays declared */
free(velocity);
free(slowness);
return 0;
}
int main(int argc, char **argv)
{
modPar mod;
recPar rec;
snaPar sna;
wavPar wav;
srcPar src;
bndPar bnd;
shotPar shot;
float **src_nwav;
float *rox, *roz, *l2m, *lam, *mul;
float *tss, *tes, *tep, *p, *q, *r;
float *vx, *vz, *tzz, *txz, *txx;
float *rec_vx, *rec_vz, *rec_p;
float *rec_txx, *rec_tzz, *rec_txz;
float *rec_pp, *rec_ss;
float *rec_udp, *rec_udvz;
float *beam_vx, *beam_vz, *beam_p;
float *beam_txx, *beam_tzz, *beam_txz;
float *beam_pp, *beam_ss;
float sinkvel;
double t0, t1, t2, t3, tt, tinit;
size_t size, sizem, nsamp, memsize;
int n1, ix, iz, ir, ishot, i;
int ioPx, ioPz;
int it0, it1, its, it, fileno, isam;
int ixsrc, izsrc;
int verbose;
t0= wallclock_time();
initargs(argc,argv);
requestdoc(0);
if (!getparint("verbose",&verbose)) verbose=0;
getParameters(&mod, &rec, &sna, &wav, &src, &shot, &bnd, verbose);
/* allocate arrays for model parameters: the different schemes use different arrays */
n1 = mod.naz;
sizem=mod.nax*mod.naz;
rox = (float *)calloc(sizem,sizeof(float));
roz = (float *)calloc(sizem,sizeof(float));
l2m = (float *)calloc(sizem,sizeof(float));
if (mod.ischeme==2) {
tss = (float *)calloc(sizem,sizeof(float));
tep = (float *)calloc(sizem,sizeof(float));
q = (float *)calloc(sizem,sizeof(float));
}
if (mod.ischeme>2) {
lam = (float *)calloc(sizem,sizeof(float));
mul = (float *)calloc(sizem,sizeof(float));
}
if (mod.ischeme==4) {
tss = (float *)calloc(sizem,sizeof(float));
tes = (float *)calloc(sizem,sizeof(float));
tep = (float *)calloc(sizem,sizeof(float));
r = (float *)calloc(sizem,sizeof(float));
p = (float *)calloc(sizem,sizeof(float));
q = (float *)calloc(sizem,sizeof(float));
}
/* read velocity and density files */
readModel(mod, bnd, rox, roz, l2m, lam, mul, tss, tes, tep);
/* read and/or define source wavelet(s) */
/* Using a random source, which can have a random length
for each source position, a pointer array with variable
length (wav.nsamp[i]) is used.
The total length of all the source lengths together is wav.nst */
if (wav.random) {
src_nwav = (float **)calloc(wav.nx,sizeof(float *));
src_nwav[0] = (float *)calloc(wav.nst,sizeof(float));
assert(src_nwav[0] != NULL);
nsamp = 0;
for (i=0; i<wav.nx; i++) {
src_nwav[i] = (float *)(src_nwav[0] + nsamp);
nsamp += wav.nsamp[i];
}
}
else {
src_nwav = (float **)calloc(wav.nx,sizeof(float *));
src_nwav[0] = (float *)calloc(wav.nt*wav.nx,sizeof(float));
assert(src_nwav[0] != NULL);
for (i=0; i<wav.nx; i++) {
src_nwav[i] = (float *)(src_nwav[0] + wav.nt*i);
}
}
defineSource(wav, src, src_nwav, mod.grid_dir, verbose);
/* allocate arrays for wavefield and receiver arrays */
vx = (float *)calloc(sizem,sizeof(float));
vz = (float *)calloc(sizem,sizeof(float));
tzz = (float *)calloc(sizem,sizeof(float)); /* =P field for acoustic */
if (mod.ischeme>2) {
txz = (float *)calloc(sizem,sizeof(float));
txx = (float *)calloc(sizem,sizeof(float));
}
if (rec.type.vz) rec_vz = (float *)calloc(size,sizeof(float));
size = rec.n*rec.nt;
if (rec.type.vz) rec_vz = (float *)calloc(size,sizeof(float));
if (rec.type.vx) rec_vx = (float *)calloc(size,sizeof(float));
if (rec.type.p) rec_p = (float *)calloc(size,sizeof(float));
if (rec.type.txx) rec_txx = (float *)calloc(size,sizeof(float));
if (rec.type.tzz) rec_tzz = (float *)calloc(size,sizeof(float));
if (rec.type.txz) rec_txz = (float *)calloc(size,sizeof(float));
if (rec.type.pp) rec_pp = (float *)calloc(size,sizeof(float));
if (rec.type.ss) rec_ss = (float *)calloc(size,sizeof(float));
if (rec.type.ud) { /* get velcity and density at first receiver location */
ir = mod.ioZz + rec.z[0]+(rec.x[0]+mod.ioZx)*n1;
rec.rho = mod.dt/(mod.dx*roz[ir]);
rec.cp = sqrt(l2m[ir]*(roz[ir]))*mod.dx/mod.dt;
rec_udvz = (float *)calloc(mod.nax*rec.nt,sizeof(float));
rec_udp = (float *)calloc(mod.nax*rec.nt,sizeof(float));
}
if(sna.beam) {
size = sna.nz*sna.nx;
if (sna.type.vz) beam_vz = (float *)calloc(size,sizeof(float));
if (sna.type.vx) beam_vx = (float *)calloc(size,sizeof(float));
if (sna.type.p) beam_p = (float *)calloc(size,sizeof(float));
if (sna.type.txx) beam_txx = (float *)calloc(size,sizeof(float));
if (sna.type.tzz) beam_tzz = (float *)calloc(size,sizeof(float));
if (sna.type.txz) beam_txz = (float *)calloc(size,sizeof(float));
if (sna.type.pp) beam_pp = (float *)calloc(size,sizeof(float));
if (sna.type.ss) beam_ss = (float *)calloc(size,sizeof(float));
}
t1= wallclock_time();
if (verbose) {
tinit = t1-t0;
vmess("*******************************************");
vmess("************* runtime info ****************");
vmess("*******************************************");
vmess("CPU time for intializing arrays and model = %f", tinit);
}
/* Sinking source and receiver arrays:
If P-velocity==0 the source and receiver
postions are placed deeper until the P-velocity changes.
The free-surface position is stored in bnd.surface[ix].
Setting the option rec.sinkvel only sinks the receiver position
(not the source) and uses the velocity
of the first receiver to sink through to the next layer. */
ioPx=mod.ioPx;
ioPz=mod.ioPz;
if (bnd.lef==4 || bnd.lef==2) ioPx += bnd.ntap;
if (bnd.top==4 || bnd.top==2) ioPz += bnd.ntap;
if (rec.sinkvel) sinkvel=l2m[(rec.x[0]+ioPx)*n1+rec.z[0]+ioPz];
else sinkvel = 0.0;
/* sink receivers to value different than sinkvel */
for (ir=0; ir<rec.n; ir++) {
iz = rec.z[ir];
ix = rec.x[ir];
while(l2m[(ix+ioPx)*n1+iz+ioPz] == sinkvel) iz++;
rec.z[ir]=iz+rec.sinkdepth;
rec.zr[ir]=rec.zr[ir]+(rec.z[ir]-iz)*mod.dz;
// rec.zr[ir]=rec.z[ir]*mod.dz;
if (verbose>3) vmess("receiver position %d at grid[ix=%d, iz=%d] = (x=%f z=%f)", ir, ix+ioPx, rec.z[ir]+ioPz, rec.xr[ir]+mod.x0, rec.zr[ir]+mod.z0);
}
/* sink sources to value different than zero */
for (ishot=0; ishot<shot.n; ishot++) {
iz = shot.z[ishot];
ix = shot.x[ishot];
while(l2m[(ix+ioPx)*n1+iz+ioPz] == 0.0) iz++;
shot.z[ishot]=iz+src.sinkdepth;
}
/* scan for free surface boundary in case it has a topography */
for (ix=0; ix<mod.nx; ix++) {
iz = ioPz;
while(l2m[(ix+ioPx)*n1+iz] == 0.0) iz++;
bnd.surface[ix+ioPx] = iz;
if ((verbose>3) && (iz != ioPz)) vmess("Topgraphy surface x=%.2f z=%.2f", mod.x0+mod.dx*ix, mod.z0+mod.dz*(iz-ioPz));
}
for (ix=0; ix<ioPx; ix++) {
bnd.surface[ix] = bnd.surface[ioPx];
}
for (ix=ioPx+mod.nx; ix<mod.iePx; ix++) {
bnd.surface[ix] = bnd.surface[mod.iePx-1];
}
if (verbose>3) writeSrcRecPos(&mod, &rec, &src, &shot);
/* Outer loop over number of shots */
for (ishot=0; ishot<shot.n; ishot++) {
izsrc = shot.z[ishot];
ixsrc = shot.x[ishot];
fileno= 0;
memset(vx,0,sizem*sizeof(float));
memset(vz,0,sizem*sizeof(float));
memset(tzz,0,sizem*sizeof(float));
if (mod.ischeme==2) {
memset(q,0,sizem*sizeof(float));
}
if (mod.ischeme>2) {
memset(txz,0,sizem*sizeof(float));
memset(txx,0,sizem*sizeof(float));
}
if (mod.ischeme==4) {
memset(r,0,sizem*sizeof(float));
memset(p,0,sizem*sizeof(float));
memset(q,0,sizem*sizeof(float));
}
if (verbose) {
if (!src.random) {
vmess("Modeling source %d at gridpoints ix=%d iz=%d", ishot, shot.x[ishot], shot.z[ishot]);
vmess(" which are actual positions x=%.2f z=%.2f", mod.x0+mod.dx*shot.x[ishot], mod.z0+mod.dz*shot.z[ishot]);
}
vmess("Receivers at gridpoint x-range ix=%d - %d", rec.x[0], rec.x[rec.n-1]);
vmess(" which are actual positions x=%.2f - %.2f", mod.x0+rec.xr[0], mod.x0+rec.xr[rec.n-1]);
vmess("Receivers at gridpoint z-range iz=%d - %d", rec.z[0], rec.z[rec.n-1]);
vmess(" which are actual positions z=%.2f - %.2f", mod.z0+rec.zr[0], mod.z0+rec.zr[rec.n-1]);
}
if (mod.grid_dir) { /* reverse time modeling */
it0=-mod.nt+1;
it1=0;
its=-1;
it0=0;
it1=mod.nt;
its=1;
}
else {
it0=0;
it1=mod.nt;
its=1;
}
/* Main loop over the number of time steps */
for (it=it0; it<it1; it++) {
#pragma omp parallel default (shared) \
shared (rox, roz, l2m, lam, mul, txx, txz, tzz, vx, vz) \
shared (tss, tep, tes, r, q, p) \
shared (tinit, it0, it1, its) \
shared(beam_vx, beam_vz, beam_txx, beam_tzz, beam_txz, beam_p, beam_pp, beam_ss) \
shared(rec_vx, rec_vz, rec_txx, rec_tzz, rec_txz, rec_p, rec_pp, rec_ss) \
private (tt, t2, t3) \
shared (shot, bnd, mod, src, wav, rec, ixsrc, izsrc, it, src_nwav, verbose)
{
switch ( mod.ischeme ) {
case 1 : /* Acoustic FD kernel */
if (mod.iorder==2) {
acoustic2(mod, src, wav, bnd, it, ixsrc, izsrc, src_nwav,
vx, vz, tzz, rox, roz, l2m, verbose);
}
else if (mod.iorder==4) {
if (mod.sh) {
acousticSH4(mod, src, wav, bnd, it, ixsrc, izsrc, src_nwav,
vx, vz, tzz, rox, roz, l2m, verbose);
}
else {
acoustic4(mod, src, wav, bnd, it, ixsrc, izsrc, src_nwav,
vx, vz, tzz, rox, roz, l2m, verbose);
}
}
else if (mod.iorder==6) {
acoustic6(mod, src, wav, bnd, it, ixsrc, izsrc, src_nwav,
vx, vz, tzz, rox, roz, l2m, verbose);
}
break;
case 2 : /* Visco-Acoustic FD kernel */
viscoacoustic4(mod, src, wav, bnd, it, ixsrc, izsrc, src_nwav,
vx, vz, tzz, rox, roz, l2m, tss, tep, q, verbose);
break;
case 3 : /* Elastic FD kernel */
if (mod.iorder==4) {
elastic4(mod, src, wav, bnd, it, ixsrc, izsrc, src_nwav,
vx, vz, tzz, txx, txz, rox, roz, l2m, lam, mul, verbose);
}
else if (mod.iorder==6) {
elastic6(mod, src, wav, bnd, it, ixsrc, izsrc, src_nwav,
vx, vz, tzz, txx, txz, rox, roz, l2m, lam, mul, verbose);
}
break;
case 4 : /* Visco-Elastic FD kernel */
viscoelastic4(mod, src, wav, bnd, it, ixsrc, izsrc, src_nwav,
vx, vz, tzz, txx, txz, rox, roz, l2m, lam, mul,
tss, tep, tes, r, q, p, verbose);
break;
}
/* write samples to file if rec.nt samples are calculated */
#pragma omp master
{
if ( (((it-rec.delay) % rec.skipdt)==0) && (it >= rec.delay) ) {
int writeToFile, itwritten;
writeToFile = ! ( (((it-rec.delay)/rec.skipdt)+1)%rec.nt );
itwritten = fileno*(rec.nt)*rec.skipdt;
isam = (it-rec.delay-itwritten)/rec.skipdt;
/* store time at receiver positions */
getRecTimes(mod, rec, bnd, it, isam, vx, vz, tzz, txx, txz,
rec_vx, rec_vz, rec_txx, rec_tzz, rec_txz,
rec_p, rec_pp, rec_ss, rec_udp, rec_udvz, verbose);
/* at the end of modeling a shot, write receiver array to output file(s) */
if (writeToFile && (it+rec.skipdt <= it1-1) ) {
fileno = ( ((it-rec.delay)/rec.skipdt)+1)/rec.nt;
writeRec(rec, mod, bnd, wav, ixsrc, izsrc, isam+1, ishot, fileno,
rec_vx, rec_vz, rec_txx, rec_tzz, rec_txz,
rec_p, rec_pp, rec_ss, rec_udp, rec_udvz, verbose);
}
}
/* write snapshots to output file(s) */
if (sna.nsnap) {
writeSnapTimes(mod, sna, ixsrc, izsrc, it, vx, vz, tzz, txx, txz, verbose);
}
/* calculate beams */
if(sna.beam) {
getBeamTimes(mod, sna, vx, vz, tzz, txx, txz,
beam_vx, beam_vz, beam_txx, beam_tzz, beam_txz,
beam_p, beam_pp, beam_ss, verbose);
}
}
/* taper the edges of the model */
// taperEdges(mod, bnd, vx, vz, verbose);
#pragma omp master
{
if (verbose) {
if (it==it0+100*its) t2=wallclock_time();
if (it==(it0+500*its)) {
t3=wallclock_time();
tt=(t3-t2)*(((it1-it0)*its)/400.0);
vmess("Estimated compute time = %.2f s. per shot.",tt);
vmess("Estimated total compute time = %.2f s.",tinit+shot.n*tt);
}
}
}
} /* end of OpenMP parallel section */
} /* end of loop over time steps it */
/* write output files: receivers and or beams */
if (fileno) fileno++;
if (rec.scale==1) { /* scale receiver with distance src-rcv */
float xsrc, zsrc, Rrec, rdx, rdz;
int irec;
xsrc=mod.x0+mod.dx*ixsrc;
zsrc=mod.z0+mod.dz*izsrc;
for (irec=0; irec<rec.n; irec++) {
rdx=mod.x0+rec.xr[irec]-xsrc;
rdz=mod.z0+rec.zr[irec]-zsrc;
Rrec = sqrt(rdx*rdx+rdz*rdz);
fprintf(stderr,"Rec %d is scaled with distance %f R=%.2f,%.2f S=%.2f,%.2f\n", irec, Rrec,rdx,rdz,xsrc,zsrc);
for (it=0; it<rec.nt; it++) {
rec_p[irec*rec.nt+it] *= sqrt(Rrec);
}
}
}
writeRec(rec, mod, bnd, wav, ixsrc, izsrc, isam+1, ishot, fileno,
rec_vx, rec_vz, rec_txx, rec_tzz, rec_txz,
rec_p, rec_pp, rec_ss, rec_udp, rec_udvz, verbose);
writeBeams(mod, sna, ixsrc, izsrc, ishot, fileno,
beam_vx, beam_vz, beam_txx, beam_tzz, beam_txz,
beam_p, beam_pp, beam_ss, verbose);
} /* end of loop over number of shots */
t1= wallclock_time();
if (verbose) {
vmess("Total compute time FD modelling = %.2f s.", t1-t0);
}
/* free arrays */
free(rox);
free(roz);
free(l2m);
free(src_nwav[0]);
free(src_nwav);
free(vx);
free(vz);
free(tzz);
if (rec.type.vz) free(rec_vz);
if (rec.type.vx) free(rec_vx);
if (rec.type.p) free(rec_p);
if (rec.type.txx) free(rec_txx);
if (rec.type.tzz) free(rec_tzz);
if (rec.type.txz) free(rec_txz);
if (rec.type.pp) free(rec_pp);
if (rec.type.ss) free(rec_ss);
if (rec.type.ud) {
free(rec_udvz);
free(rec_udp);
}
if(sna.beam) {
if (sna.type.vz) free(beam_vz);
if (sna.type.vx) free(beam_vx);
if (sna.type.p) free(beam_p);
if (sna.type.txx) free(beam_txx);
if (sna.type.tzz) free(beam_tzz);
if (sna.type.txz) free(beam_txz);
if (sna.type.pp) free(beam_pp);
if (sna.type.ss) free(beam_ss);
}
if (mod.ischeme==2) {
free(tss);
free(tep);
free(q);
}
if (mod.ischeme>2) {
free(lam);
free(mul);
free(txz);
free(txx);
}
if (mod.ischeme==4) {
free(tss);
free(tes);
free(tep);
free(r);
free(p);
free(q);
}
return 0;
}
