void pml_txx(float **txxn1, float **vxn1, float **vzn1, float **c11, float (*ldx)(float **, int, int), float (*ldz)(float **, int, int), bool freesurface ) /*<stress decay in pml>*/ { int ix, iz; /*Stress PML -- top*/ if (freesurface == false) { for (ix=marg; ix<nx+2*pmlout+marg; ix++) { for (iz=marg; iz<marg+pmlout; iz++) { txxn1x[ix][iz]=((1-dt*pmldx[ix]/2)*txxn0x[ix][iz]-dt*c11[ix][iz]*ldx(vxn1,ix-1,iz))/(1+dt*pmldx[ix]/2); txxn1z[ix][iz]=((1-dt*pmldz[iz]/2)*txxn0z[ix][iz]-dt*c11[ix][iz]*ldz(vzn1,ix,iz-1))/(1+dt*pmldz[iz]/2); txxn1[ix][iz] = txxn1x[ix][iz]+txxn1z[ix][iz]; } } } else { for (ix=marg; ix<nx+2*pmlout+marg; ix++) { for (iz=marg; iz<marg+pmlout; iz++) { txxn1x[ix][iz]=((1-dt*pmldx[ix]/2)*txxn0x[ix][iz]-dt*0.0*ldx(vxn1,ix-1,iz))/(1+dt*pmldx[ix]/2); txxn1z[ix][iz]=((1-dt*pmldz[iz]/2)*txxn0z[ix][iz]-dt*0.0*ldz(vzn1,ix,iz-1))/(1+dt*pmldz[iz]/2); txxn1[ix][iz] = txxn1x[ix][iz]+txxn1z[ix][iz]; } } } /*Stress PML -- left*/ for (ix=marg; ix<marg+pmlout; ix++) { for (iz=marg+pmlout; iz<nz+pmlout+marg; iz++) { txxn1x[ix][iz]=((1-dt*pmldx[ix]/2)*txxn0x[ix][iz]-dt*c11[ix][iz]*ldx(vxn1,ix-1,iz))/(1+dt*pmldx[ix]/2); txxn1z[ix][iz]=((1-dt*pmldz[iz]/2)*txxn0z[ix][iz]-dt*c11[ix][iz]*ldz(vzn1,ix,iz-1))/(1+dt*pmldz[iz]/2); txxn1[ix][iz] = txxn1x[ix][iz]+txxn1z[ix][iz]; } } /*Stress PML -- right*/ for (ix=nx+pmlout+marg; ix<nx+2*pmlout+marg; ix++) { for (iz=marg+pmlout; iz<nz+pmlout+marg; iz++) { txxn1x[ix][iz]=((1-dt*pmldx[ix]/2)*txxn0x[ix][iz]-dt*c11[ix][iz]*ldx(vxn1,ix-1,iz))/(1+dt*pmldx[ix]/2); txxn1z[ix][iz]=((1-dt*pmldz[iz]/2)*txxn0z[ix][iz]-dt*c11[ix][iz]*ldz(vzn1,ix,iz-1))/(1+dt*pmldz[iz]/2); txxn1[ix][iz] = txxn1x[ix][iz]+txxn1z[ix][iz]; } } /*Stress PML -- bottom*/ for (ix=marg; ix<nx+2*pmlout+marg; ix++) { for (iz=marg+pmlout+nz; iz<nz+2*pmlout+marg; iz++) { txxn1x[ix][iz]=((1-dt*pmldx[ix]/2)*txxn0x[ix][iz]-dt*c11[ix][iz]*ldx(vxn1,ix-1,iz))/(1+dt*pmldx[ix]/2); txxn1z[ix][iz]=((1-dt*pmldz[iz]/2)*txxn0z[ix][iz]-dt*c11[ix][iz]*ldz(vzn1,ix,iz-1))/(1+dt*pmldz[iz]/2); txxn1[ix][iz] = txxn1x[ix][iz]+txxn1z[ix][iz]; } } }
void pml_vxz(float **vxn1, float **vzn1, float **vxn0, float **vzn0, float **txxn0, float **denx, float **denz, float (*ldx)(float **, int, int), float (*ldz)(float **, int, int), bool freesurface) /*<velocity vx,vz decay in pml>*/ { int ix, iz; /*Velocity PML --top*/ if (freesurface == false) { for (ix=marg; ix<nx+2*pmlout+marg; ix++) { for (iz=marg; iz<marg+pmlout; iz++) { vxn1[ix][iz]=((1-dt*pmldx[ix]/2)*vxn0[ix][iz]-dt/denx[ix][iz]*ldx(txxn0,ix,iz))/(1+dt*pmldx[ix]/2); vzn1[ix][iz]=((1-dt*pmldz[iz]/2)*vzn0[ix][iz]-dt/denz[ix][iz]*ldz(txxn0,ix,iz))/(1+dt*pmldz[iz]/2); } } } /*Velocity PML --left*/ for (ix=marg; ix<marg+pmlout; ix++) { for (iz=marg+pmlout; iz<nz+pmlout+marg; iz++) { vxn1[ix][iz]=((1-dt*pmldx[ix]/2)*vxn0[ix][iz]-dt/denx[ix][iz]*ldx(txxn0,ix,iz))/(1+dt*pmldx[ix]/2); vzn1[ix][iz]=((1-dt*pmldz[iz]/2)*vzn0[ix][iz]-dt/denz[ix][iz]*ldz(txxn0,ix,iz))/(1+dt*pmldz[iz]/2); } } /*Velocity PML --right*/ for (ix=nx+pmlout+marg; ix<nx+2*pmlout+marg; ix++) { for (iz=marg+pmlout; iz<nz+pmlout+marg; iz++) { vxn1[ix][iz]=((1-dt*pmldx[ix]/2)*vxn0[ix][iz]-dt/denx[ix][iz]*ldx(txxn0,ix,iz))/(1+dt*pmldx[ix]/2); vzn1[ix][iz]=((1-dt*pmldz[iz]/2)*vzn0[ix][iz]-dt/denz[ix][iz]*ldz(txxn0,ix,iz))/(1+dt*pmldz[iz]/2); } } /*Velocity PML --bottom*/ for (ix=marg; ix<nx+2*pmlout+marg; ix++) { for (iz=marg+pmlout+nz; iz<nz+2*pmlout+marg; iz++) { vxn1[ix][iz]=((1-dt*pmldx[ix]/2)*vxn0[ix][iz]-dt/denx[ix][iz]*ldx(txxn0,ix,iz))/(1+dt*pmldx[ix]/2); vzn1[ix][iz]=((1-dt*pmldz[iz]/2)*vzn0[ix][iz]-dt/denz[ix][iz]*ldz(txxn0,ix,iz))/(1+dt*pmldz[iz]/2); } } }
int sglfdback2(float ***mig1, float **mig2, float ***fwf, float **localrec, bool verb, bool wantwf, sf_file Ftmpbwf) { float **txxn1, **txxn0, **vxn1, **vxn0, **vzn1, **vzn0; float **sill, **ccr, ***bwf; int wfit, htau; float tau; sill=sf_floatalloc2(nz, nx); ccr=sf_floatalloc2(nz, nx); bwf=sf_floatalloc3(nz, nx, wfnt); zero2(sill, nz, nx); zero2(ccr, nz, nx); zero3(mig1, nz, nx, ntau); txxn1=sf_floatalloc2(nzb, nxb); txxn0=sf_floatalloc2(nzb, nxb); vxn1=sf_floatalloc2(nzb, nxb); vxn0=sf_floatalloc2(nzb, nxb); vzn1=sf_floatalloc2(nzb, nxb); vzn0=sf_floatalloc2(nzb, nxb); zero2(txxn1, nzb, nxb); zero2(txxn0, nzb, nxb); zero2(vxn1, nzb, nxb); zero2(vxn0, nzb, nxb); zero2(vzn1, nzb, nxb); zero2(vzn0, nzb, nxb); zero2(txxn1x, nzb, nxb); zero2(txxn1z, nzb, nxb); zero2(txxn0x, nzb, nxb); zero2(txxn0z, nzb, nxb); wfit=wfnt-1; for(it=nt-1; it>=0; it--){ if(verb) sf_warning("Backward it=%d/%d;", it+1, nt); #ifdef _OPENMP #pragma omp parallel for private(ix,iz) #endif for(ix=nfd+pmlsize; ix<nfd+pmlsize+nx; ix++){ for(iz=nfd+pmlsize; iz<nfd+pmlsize+nz; iz++){ txxn0[ix][iz]=txxn1[ix][iz]+dt*bc11[ix][iz]*(ldx(vxn1, ix-1, iz) +ldz(vzn1, ix, iz-1)); } } pml_txxb(txxn0, vxn1, vzn1); #ifdef _OPENMP #pragma omp parallel for private(ix) #endif for(ix=0; ix<ng; ix++){ txxn0[ix*ginv+pmlsize+nfd][pmlsize+nfd+gp]+=localrec[ix][it]; } #ifdef _OPENMP #pragma omp parallel for private(ix,iz) #endif for(ix=nfd+pmlsize; ix<nfd+pmlsize+nx; ix++){ for(iz=nfd+pmlsize; iz<nfd+pmlsize+nz; iz++){ vxn0[ix][iz]=vxn1[ix][iz]+dt/bdenx[ix][iz]*ldx(txxn0, ix, iz); vzn0[ix][iz]=vzn1[ix][iz]+dt/bdenz[ix][iz]*ldz(txxn0, ix, iz); } } pml_vxzb(vxn1, vzn1, vxn0, vzn0, txxn0); transp=txxn1; txxn1=txxn0; txxn0=transp; transp=vxn1; vxn1=vxn0; vxn0=transp; transp=vzn1; vzn1=vzn0; vzn0=transp; if(it%wfinv==0){ for(ix=0; ix<nx; ix++) for(iz=0; iz<nz; iz++){ bwf[wfit][ix][iz]=txxn0[ix+pmlsize+nfd][iz+pmlsize+nfd]; ccr[ix][iz]+=fwf[wfit][ix][iz]*bwf[wfit][ix][iz]; sill[ix][iz]+=fwf[wfit][ix][iz]*fwf[wfit][ix][iz]; } wfit--; } } //end of it if(verb) sf_warning("."); for(itau=0; itau<ntau; itau++){ tau=itau*dtau+tau0; htau=tau/wfdt; for(it=abs(htau); it<wfnt-abs(htau); it++){ for(ix=0; ix<nx; ix++){ for(iz=0; iz<nz; iz++){ mig1[itau][ix][iz]+=fwf[it+htau][ix][iz]*bwf[it-htau][ix][iz]; } } }//end of it } // end of itau for(ix=0; ix<nx; ix++){ for(iz=0; iz<nz; iz++){ mig2[ix][iz]=ccr[ix][iz]/(sill[ix][iz]+SF_EPS); } } if(wantwf) sf_floatwrite(bwf[0][0], wfnt*nx*nz, Ftmpbwf); return 0; }
int sglfdfor2(float ***fwf, float **rcd, bool verb) { float **txxn1, **txxn0, **vxn1, **vxn0, **vzn1, **vzn0; int wfit; txxn1=sf_floatalloc2(nzb, nxb); txxn0=sf_floatalloc2(nzb, nxb); vxn1=sf_floatalloc2(nzb, nxb); vxn0=sf_floatalloc2(nzb, nxb); vzn1=sf_floatalloc2(nzb, nxb); vzn0=sf_floatalloc2(nzb, nxb); zero2(txxn1, nzb, nxb); zero2(txxn0, nzb, nxb); zero2(vxn1, nzb, nxb); zero2(vxn0, nzb, nxb); zero2(vzn1, nzb, nxb); zero2(vzn0, nzb, nxb); zero2(txxn1x, nzb, nxb); zero2(txxn1z, nzb, nxb); zero2(txxn0x, nzb, nxb); zero2(txxn0z, nzb, nxb); wfit=0; for(it=0; it<nt; it++){ // sf_warning("test txxn1[801][30]=%d",txxn1[801][30]) if(verb) sf_warning("Forward it=%d/%d;", it+1, nt); #ifdef _OPENMP #pragma omp parallel for private(ix,iz) #endif for(ix=nfd+pmlsize; ix<nfd+pmlsize+nx; ix++){ for(iz=nfd+pmlsize; iz<nfd+pmlsize+nz; iz++){ vxn1[ix][iz]=vxn0[ix][iz]-dt/fdenx[ix][iz]*ldx(txxn0, ix, iz); vzn1[ix][iz]=vzn0[ix][iz]-dt/fdenz[ix][iz]*ldz(txxn0, ix, iz); } } pml_vxz(vxn1, vzn1, vxn0, vzn0, txxn0); #ifdef _OPENMP #pragma omp parallel for private(ix,iz) #endif for(ix=nfd+pmlsize; ix<nfd+pmlsize+nx; ix++){ for(iz=nfd+pmlsize; iz<nfd+pmlsize+nz; iz++){ txxn1[ix][iz]=txxn0[ix][iz]-dt*fc11[ix][iz]*(ldx(vxn1, ix-1, iz) + ldz(vzn1, ix, iz-1)); } } pml_txx(txxn1, vxn1, vzn1); if((it*dt)<srctrunc){ explsource(txxn1); } if(it%wfinv==0){ #ifdef _OPENMP #pragma omp parallel for private(ix,iz) #endif for(ix=0; ix<nx; ix++){ for(iz=0; iz<nz; iz++){ fwf[wfit][ix][iz]=txxn0[ix+nfd+pmlsize][iz+nfd+pmlsize]; } } wfit++; } #ifdef _OPENMP #pragma omp parallel for private(ix) #endif for(ix=0; ix<ng; ix++){ rcd[ix][it]=txxn0[ix*ginv+pmlsize+nfd][pmlsize+nfd+gp]; } transp=txxn0; txxn0=txxn1; txxn1=transp; transp=vxn0; vxn0=vxn1; vxn1=transp; transp=vzn0; vzn0=vzn1; vzn1=transp; } // end of it if(verb) sf_warning("."); return 0;; }
void build(const pixmap<T> &source, const size_t links) { assert(same_metrics_than(source)); assert(4==links||8==links); _tagmap &self = *this; //______________________________________________________________ // // initialize all //______________________________________________________________ current = 0; ldz(); vstk.free(); for(unit_t j=0;j<h;++j) { row &tag_j = self[j]; const typename pixmap<T>::row &src_j = source[j]; for(unit_t i=0;i<w;++i) { size_t &tag = tag_j[i]; if(0==tag) { //__________________________________________________ // // no current tag //__________________________________________________ if(!pixel<T>::is_zero(src_j[i])) { //______________________________________________ // // start a new tag ! //______________________________________________ tag = ++current; //______________________________________________ // // initialize stack //______________________________________________ vstk.free(); { const vertex here(i,j); vstk.push(here); } //______________________________________________ // // not recursive build //______________________________________________ while( vstk.size() > 0 ) { //__________________________________________ // // remove one vertex from stack //__________________________________________ const vertex here = vstk.peek(); assert(self[here]==current); vstk.pop(); //__________________________________________ // // probe neighbors //__________________________________________ for(size_t k=0;k<links;++k) { const vertex probe = here + gist::delta[k]; if(source.has(probe) && 0==self[probe] && !pixel<T>::is_zero(source[probe])) { self[probe]=current; vstk.push(probe); } } } } } } } vstk.free(); }
void EdgeDetector:: post_build(xpatches &xps) { edges.free(); // get the global max Gmax = xps[1].as<float>(); for(size_t i=xps.size();i>1;--i) { Gmax = max_of(Gmax,xps[i].as<float>()); } if(Gmax>0) { //! normalize as probability xps.submit(this, &EdgeDetector::normalize ); //! non local maxima suprresion xps.submit(this, &EdgeDetector::non_maxima_suppress); //! thresholds computation H.reset(); H.update(E,xps); level_up = H.threshold(); const size_t level_min = level_lo/2; const size_t level_delta = size_t( floor( (level_up-level_min) * weak_intake + 0.5f) ); level_lo = level_up-level_delta; //! apply threshold xps.submit(this, &EdgeDetector::apply_thresholds); //! build blobs tags.build(E,8); //! find individual edges edges.load(tags); // removing weak only edges pixmap<float> &G = *this; for(size_t i=edges.size();i>0;--i) { particle &p = *edges[i]; assert(p.size>0); assert(p.inside.size<=0); assert(p.border.size<=0); // detect if at least one strong connected edge bool is_strong = false; for(const vnode *node = p.head;node;node=node->next) { if(STRONG==E[node->vtx]) { is_strong=true; break; } } // remove it ! if(!is_strong) { while(p.size) { vnode *node = p.pop_back(); const vertex q = node->vtx; tags[q] = 0; E[q] = 0; G[q] = 0; delete node; } } } remove_if(edges,__is_empty_particle); //std::cerr << "#edges=" << edges.size() << std::endl; } else { ldz(); E.ldz(); tags.ldz(); } }
int sglfdfor2(float ***wavfld, float **rcd, bool verb, float **den, float **c11, geopar geop, srcpar srcp, pmlpar pmlp) /*< staggered grid lowrank FD forward modeling >*/ { /*caculate arrays*/ float **txxn1, **txxn0, **vxn1, **vzn1, **vxn0, **vzn0; float **denx, **denz; /*grid index*/ int nx, nz, nt, ix, iz, it; int nxb, nzb, snpint; int spx, spz, gp, gn, ginter; float dt, dx, dz; int pmlout, marg; bool freesurface; /* tmp variable */ int wfit; int nth; nx = geop->nx; nz = geop->nz; nxb = geop->nxb; nzb = geop->nzb; dx = geop->dx; dz = geop->dz; spx = geop->spx; spz = geop->spz; gp = geop->gp; gn = geop->gn; ginter = geop->ginter; snpint = geop->snpint; nt = srcp->nt; dt = srcp->dt; pmlout = pmlp->pmlout; freesurface = pmlp->freesurface; marg = getmarg(); denx = sf_floatalloc2(nzb, nxb); denz = sf_floatalloc2(nzb, nxb); #ifdef _OPENMP #pragma omp parallel { nth = omp_get_num_threads(); } #endif sf_warning(">>>> Using %d threads <<<<<", nth); #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for ( iz= 0; iz < nzb; iz++) { denx[ix][iz] = den[ix][iz]; denz[ix][iz] = den[ix][iz]; } } /*den[ix+1/2][iz]*/ #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for ( ix = 0; ix < nxb-1; ix++) { for (iz = 0; iz < nzb; iz++) { denx[ix][iz] = (den[ix+1][iz] + den[ix][iz])*0.5; } } /*den[ix][iz+1/2]*/ #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for ( ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb-1; iz++) { denz[ix][iz] = (den[ix][iz+1] + den[ix][iz])*0.5; } } txxn1 = sf_floatalloc2(nzb, nxb); txxn0 = sf_floatalloc2(nzb, nxb); vxn1 = sf_floatalloc2(nzb, nxb); vzn1 = sf_floatalloc2(nzb, nxb); vxn0 = sf_floatalloc2(nzb, nxb); vzn0 = sf_floatalloc2(nzb, nxb); init_pml(nz, nx, dt, marg, pmlp); #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { txxn1[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { txxn0[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { vxn1[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { vxn0[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { vzn1[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { vzn0[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (it = 0; it < nt; it++) { for (ix = 0; ix < gn; ix++) { rcd[ix][it] = 0.0; } } /*Main loop*/ wfit = 0; for (it = 0; it < nt; it++) { if (verb) sf_warning("Forward it=%d/%d;", it, nt-1); /*velocity*/ #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = marg+pmlout; ix < nx+pmlout+marg; ix++ ) { for (iz = marg+pmlout; iz < nz+pmlout+marg; iz++) { vxn1[ix][iz] = vxn0[ix][iz] - dt/denx[ix][iz]*ldx(txxn0, ix, iz); vzn1[ix][iz] = vzn0[ix][iz] - dt/denz[ix][iz]*ldz(txxn0, ix, iz); } } /*Velocity PML */ pml_vxz(vxn1, vzn1, vxn0, vzn0, txxn0, denx, denz, ldx, ldz, freesurface); /*Stress*/ #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = marg+pmlout; ix < nx+marg+pmlout; ix++) { for ( iz = marg+pmlout; iz < nz+marg+pmlout; iz++) { txxn1[ix][iz] = txxn0[ix][iz] - dt*c11[ix][iz]*(ldx(vxn1, ix-1, iz) + ldz(vzn1, ix, iz-1)); } } /*Stress PML */ pml_txx(txxn1, vxn1, vzn1, c11, ldx, ldz, freesurface); if ((it*dt)<=srcp->trunc) { explsourcet(txxn1, srcp->wavelet, it, dt, spx+pmlout+marg, spz+pmlout+marg, nxb, nzb, srcp); } if ( it%snpint == 0 ) { #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for ( ix = 0; ix < nx; ix++) for ( iz = 0; iz<nz; iz++ ) wavfld[wfit][ix][iz] = txxn0[ix+pmlout+marg][iz+pmlout+marg]; wfit++; } //sf_warning("test I am at 257"); #ifdef _OPENMP #pragma omp parallel for private(ix) #endif for ( ix =0 ; ix < gn; ix++) { rcd[ix][it] = txxn0[ix*ginter+pmlout+marg][pmlout+marg+gp]; //sf_warning("gn=%d ix=%d ginter=%d ix*ginter=%d", gn, ginter, ix, ix*ginter); } //sf_warning("test I am at 266"); /*n1 -> n0*/ time_step_exch(txxn0, txxn1, it); time_step_exch(vxn0, vxn1, it); time_step_exch(vzn0, vzn1, it); pml_tstep_exch(it); } /*Main loop*/ if (verb) sf_warning("."); return wfit; }
int sglfdback2(float **img1, float **img2, float ***wavfld, float **rcd, bool verb, bool wantwf, float **den, float **c11, geopar geop, srcpar srcp, pmlpar pmlp, sf_file Ftmpbwf) /*< staggered grid lowrank FD backward propagation + imaging >*/ { /*caculate arrays*/ float **txxn1, **txxn0, **vxn1, **vzn1, **vxn0, **vzn0; float **denx, **denz; float **sill, **ccr; /*grid index*/ int nx, nz, nt, ix, iz, it, gn, ginter; int nxb, nzb, snpint; int gp; float dt, dx, dz; int pmlout, marg; bool freesurface; /* tmp variable */ int wfit; nx = geop->nx; nz = geop->nz; nxb = geop->nxb; nzb = geop->nzb; dx = geop->dx; dz = geop->dz; gp = geop->gp; gn = geop->gn; ginter= geop->ginter; snpint = geop->snpint; nt = srcp->nt; dt = srcp->dt; pmlout = pmlp->pmlout; freesurface = pmlp->freesurface; marg = getmarg(); denx = sf_floatalloc2(nzb, nxb); denz = sf_floatalloc2(nzb, nxb); sill = sf_floatalloc2(nz, nx); ccr = img1; #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for ( iz= 0; iz < nzb; iz++) { denx[ix][iz] = den[ix][iz]; denz[ix][iz] = den[ix][iz]; } } /*den[ix+1/2][iz]*/ #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for ( ix = 0; ix < nxb-1; ix++) { for (iz = 0; iz < nzb; iz++) { denx[ix][iz] = (den[ix+1][iz] + den[ix][iz])*0.5; } } /*den[ix][iz+1/2]*/ #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for ( ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb-1; iz++) { denz[ix][iz] = (den[ix][iz+1] + den[ix][iz])*0.5; } } txxn1 = sf_floatalloc2(nzb, nxb); txxn0 = sf_floatalloc2(nzb, nxb); vxn1 = sf_floatalloc2(nzb, nxb); vzn1 = sf_floatalloc2(nzb, nxb); vxn0 = sf_floatalloc2(nzb, nxb); vzn0 = sf_floatalloc2(nzb, nxb); init_pml(nz, nx, dt, marg, pmlp); #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { txxn1[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { txxn0[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { vxn1[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { vxn0[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { vzn1[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nxb; ix++) { for (iz = 0; iz < nzb; iz++) { vzn0[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nx; ix++) { for (iz = 0; iz < nz; iz++) { sill[ix][iz] = 0.0; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = 0; ix < nx; ix++) { for (iz = 0; iz < nz; iz++) { ccr[ix][iz] = 0.0; } } /*Main loop*/ wfit = (int)(nt-1)/snpint; for (it = nt-1; it>=0; it--) { if (verb) sf_warning("Backward it=%d/%d;", it, nt-1); /*Stress*/ #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = marg+pmlout; ix < nx+marg+pmlout; ix++) { for ( iz = marg+pmlout; iz < nz+marg+pmlout; iz++) { txxn0[ix][iz] = txxn1[ix][iz] + dt*c11[ix][iz]*(ldx(vxn1, ix-1, iz) + ldz(vzn1, ix, iz-1)); } } /*Stress PML */ pml_txxb(txxn0, vxn1, vzn1, c11, ldx, ldz, freesurface); #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix=0; ix<gn; ix++) { txxn0[ix*ginter+pmlout+marg][pmlout+marg+gp] = rcd[ix][it]; } /*velocity*/ #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix = marg+pmlout; ix < nx+pmlout+marg; ix++ ) { for (iz = marg+pmlout; iz < nz+pmlout+marg; iz++) { vxn0[ix][iz] = vxn1[ix][iz] + dt/denx[ix][iz]*ldx(txxn0, ix, iz); vzn0[ix][iz] = vzn1[ix][iz] + dt/denz[ix][iz]*ldz(txxn0, ix, iz); } } /*Velocity PML */ pml_vxzb(vxn1, vzn1, vxn0, vzn0, txxn0, denx, denz, ldx, ldz, freesurface); /*n1 -> n0*/ time_step_exch(txxn1, txxn0, it); time_step_exch(vxn1, vxn0, it); time_step_exch(vzn1, vzn0, it); pml_tstep_exchb(it); if ( wantwf && it%snpint == 0 ) { for ( ix = 0; ix < nx; ix++) sf_floatwrite(txxn0[ix+pmlout+marg]+pmlout+marg, nz, Ftmpbwf); } if (it%snpint == 0 ) { #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix=0; ix<nx; ix++) { for (iz=0; iz<nz; iz++) { ccr[ix][iz] += wavfld[wfit][ix][iz]*txxn0[ix+pmlout+marg][iz+pmlout+marg]; } } #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix=0; ix<nx; ix++) { for (iz=0; iz<nz; iz++) { sill[ix][iz] += wavfld[wfit][ix][iz]*wavfld[wfit][ix][iz]; } } wfit--; } } /*Main loop*/ if (verb) sf_warning("."); #ifdef _OPENMP #pragma omp parallel for private(ix, iz) #endif for (ix=0; ix<nx; ix++) { for (iz=0; iz<nz; iz++) { img2[ix][iz] = ccr[ix][iz]/(sill[ix][iz]+SF_EPS);// } } return 0; }