void ExplorerPropertySheet(HWND hparent) { PropertySheetDialog ps(hparent); ps.dwFlags |= PSH_USEICONID | PSH_PROPTITLE; ps.pszIcon = MAKEINTRESOURCE(IDI_REACTOS); ps.pszCaption = TEXT("Explorer"); PropSheetPage psp1(IDD_DESKBAR_DESKTOP, WINDOW_CREATOR(DesktopSettingsDlg)); psp1.dwFlags |= PSP_USETITLE; psp1.pszTitle = MAKEINTRESOURCE(IDS_DESKTOP); ps.add(psp1); PropSheetPage psp2(IDD_DESKBAR_TASKBAR, WINDOW_CREATOR(TaskbarSettingsDlg)); psp2.dwFlags |= PSP_USETITLE; psp2.pszTitle = MAKEINTRESOURCE(IDS_TASKBAR); ps.add(psp2); PropSheetPage psp3(IDD_DESKBAR_STARTMENU, WINDOW_CREATOR(StartmenuSettingsDlg)); psp3.dwFlags |= PSP_USETITLE; psp3.pszTitle = MAKEINTRESOURCE(IDS_STARTMENU); ps.add(psp3); ps.DoModal(); }
void Tri2dFCBlockSolver::gradSetup() { // set up averaged quadratic gradient coefficients if (gradMethod == 0 || gradMethod == 2){ gxQ.allocate(npsp1,2); gradSetupQuadratic(); } // set up fully cubic gradient coefficients gxC.allocate(npsp1,2); gradSetupCubic(); // copy the proper coefficients based on desired gradient method if (gradMethod == 0) for (int n=0; n<npsp1; n++) for (int k=0; k<2; k++) gx(n,k) = gxQ(n,k); else if (gradMethod == 1) for (int n=0; n<npsp1; n++) for (int k=0; k<2; k++) gx(n,k) = gxC(n,k); else if (gradMethod == 2){ for (int n=0; n<npsp1; n++) for (int k=0; k<2; k++) gx(n,k) = gxC(n,k); for (int n=nNode-nNodeBd; n<nNode; n++) for(int i=psp2(n); i<psp2(n+1); i++) for (int k=0; k<2; k++) gx(i,k) = gxQ(i,k); } else{ cout << "\ngradMethod not recognized in gradSetup.C" << endl; exit(0); } // deallocate work arrays gxQ.deallocate(); gxC.deallocate(); }
void Strand2dFCBlockSolver::gradStencil() { // create linked lists of surface elements surrounding surface points int* surfEsp2 = new int[nSurfNode]; for (int n=0; n<nSurfNode; n++) surfEsp2[n] = 0; for (int n=0; n<nSurfElem; n++) for (int k=0; k<meshOrder+1; k++) surfEsp2[surfElem(n,k)]++; int** surfEsp1 = new int*[nSurfNode]; for (int n=0; n<nSurfNode; n++){ if (surfEsp2[n] > 0) surfEsp1[n] = new int[surfEsp2[n]]; else surfEsp1[n] = NULL; } int j; for (int n=0; n<nSurfNode; n++) surfEsp2[n] = 0; for (int n=0; n<nSurfElem; n++) for (int k=0; k<meshOrder+1; k++){ j = surfEsp2[surfElem(n,k)]; surfEsp1[surfElem(n,k)][j] = n; surfEsp2[surfElem(n,k)]++; } /* for (int n=0; n<nSurfNode; n++){ cout << n << " "; for (int j=0; j<surfEsp2[n]; j++) cout << surfEsp1[n][j] << " "; cout << endl; } exit(0); */ int i,m,n1,n2; Array1D<int> flag(nSurfNode); psp2.allocate(nSurfNode+1); psp2.set(0); flag.set(-1); for (int n=0; n<nSurfNode; n++) for (int l=0; l<surfEsp2[n]; l++){ i = surfEsp1[n][l]; for (int k=0; k<meshOrder+1; k++){ m = surfElem(i,k); if (flag(m) != n){ psp2(n+1)++; flag(m) = n; }}} /* for (int n=0; n<nNode; n++) cout << n << " " << psp2(n+1) << endl; exit(0); */ for(int n=1; n<nSurfNode+1; n++) psp2(n) += psp2(n-1); npsp1 = psp2(nSurfNode); psp1.allocate(npsp1); flag.set(-1); for (int n=0; n<nSurfNode; n++) for (int l=0; l<surfEsp2[n]; l++){ i = surfEsp1[n][l]; for (int k=0; k<meshOrder+1; k++){ m = surfElem(i,k); if (flag(m) != n){ psp1(psp2(n)++) = m; flag(m) = n; }}} for(int n=nSurfNode; n>0; n--) psp2(n) = psp2(n-1); psp2(0) = 0; /* for (int n=0; n<nSurfNode; n++){ cout << "\nSurfNode: " << n << " " << psp2(n+1)-psp2(n) << endl; for (int i=psp2(n); i<psp2(n+1); i++) cout << psp1(i) << endl; } exit(0); */ // deallocate work arrays for (int n=0; n<nSurfNode; n++) if (surfEsp1[n]) delete [] surfEsp1[n]; delete [] surfEsp1; delete [] surfEsp2; flag.deallocate(); }
void Strand2dFCBlockSolver::gradSetupSub(Array3D<double>& gx) { // initialize coefficient array gx.set(0.); // form quadratic sub elements int meshOrderL=2,nElemLocalL=meshOrder-1,nSurfElemL=nSurfElem*nElemLocalL; Array3D<int> surfElemL(nSurfElemL,meshOrderL+1,2); Array3D<int> elemLocalL(nElemLocalL,meshOrderL+1,2); if (meshOrder == 2){ elemLocalL(0,0,0) = 0; elemLocalL(0,0,1) = 1; elemLocalL(0,1,0) = 1; elemLocalL(0,1,1) = 1; elemLocalL(0,2,0) = 2; elemLocalL(0,2,1) = 1; } else if (meshOrder == 3){ elemLocalL(0,0,0) = 0; elemLocalL(0,0,1) = 1; elemLocalL(0,1,0) = 3; elemLocalL(0,1,1) = 0; elemLocalL(0,2,0) = 2; elemLocalL(0,2,1) = 1; elemLocalL(1,0,0) = 2; elemLocalL(1,0,1) = 0; elemLocalL(1,1,0) = 1; elemLocalL(1,1,1) = 1; elemLocalL(1,2,0) = 3; elemLocalL(1,2,1) = 1; } else if (meshOrder == 4){ elemLocalL(0,0,0) = 0; elemLocalL(0,0,1) = 1; elemLocalL(0,1,0) = 3; elemLocalL(0,1,1) = 0; elemLocalL(0,2,0) = 2; elemLocalL(0,2,1) = 1; elemLocalL(1,0,0) = 2; elemLocalL(1,0,1) = 0; elemLocalL(1,1,0) = 4; elemLocalL(1,1,1) = 0; elemLocalL(1,2,0) = 3; elemLocalL(1,2,1) = 1; elemLocalL(2,0,0) = 3; elemLocalL(2,0,1) = 0; elemLocalL(2,1,0) = 1; elemLocalL(2,1,1) = 1; elemLocalL(2,2,0) = 4; elemLocalL(2,2,1) = 1; } int k=0; for (int n=0; n<nSurfElem; n++) for (int i=0; i<nElemLocalL; i++){ for (int m=0; m<meshOrderL+1; m++){ surfElemL(k,m,0) = surfElem(n,elemLocalL(i,m,0)); surfElemL(k,m,1) = elemLocalL(i,m,1); } k++; } if (k != nSurfElemL){ cout << "\n***Problem forming sub-elements in initialize.C***" << endl; exit(0); } // Lagrange polynomial derivatives for lower order elements int spacing=0; // assume equally spaced points in surface elements for now Array1D<double> ss(meshOrderL+1); solutionPoints1D(meshOrderL, spacing, &ss(0)); bool test=false; Array2D<double> lc(meshOrderL+1,meshOrderL+1); lagrangePoly1D(test, // coefficients to form Lagrange polynomials meshOrderL, &ss(0), &lc(0,0)); // ls(i,j) = (dl_j/ds)_i (a row is all Lagrange polynomials (derivatives) // evaluated at a single mesh point i) Array2D<double> lsL(meshOrderL+1,meshOrderL+1); lsL.set(0.); int km; for (int i=0; i<meshOrderL+1; i++) // ith mesh point for (int j=0; j<meshOrderL+1; j++) // jth Lagrange polynomial for (int k=0; k<meshOrderL+1; k++){ km = max(0,k-1); lsL(i,j) +=((double)k)*pow(ss(i),km)*lc(j,k); } // mapping terms for lower order elements Array3D<double> xsL(nSurfElemL,meshOrderL+1,nStrandNode); Array3D<double> ysL(nSurfElemL,meshOrderL+1,nStrandNode); Array3D<double> jacL(nSurfElemL,meshOrderL+1,nStrandNode); xsL.set(0.); ysL.set(0.); int ni,nm; double x0,y0,nx,ny; for (int n=0; n<nSurfElemL; n++) for (int i=0; i<meshOrderL+1; i++){ // ith point in the element ni = surfElemL(n,i,0); for (int m=0; m<meshOrderL+1; m++){ // mth Lagrange poly. in mapping nm = surfElemL(n,m,0); x0 = surfX(nm,0); y0 = surfX(nm,1); nx = pointingVec(nm,0); ny = pointingVec(nm,1); for (int j=0; j<nStrandNode; j++){ xsL(n,i,j) += lsL(i,m)*(x0+nx*strandX(j)); ysL(n,i,j) += lsL(i,m)*(y0+ny*strandX(j)); }} for (int j=0; j<nStrandNode; j++) jacL(n,i,j) = xsL(n,i,j)*yn(ni,j)-ysL(n,i,j)*xn(ni,j); } // degree at each surface node Array1D<int> sum(nSurfNode); sum.set(0); for (int n=0; n<nSurfElemL; n++) for (int i=0; i<meshOrderL+1; i++) sum(surfElemL(n,i,0)) += surfElemL(n,i,1); // use elements to form gradient coefficients double xnj,ynj; Array3D<double> a(nSurfNode,nStrandNode,2); a.set(0.); for (int n=0; n<nSurfElemL; n++) for (int i=0; i<meshOrderL+1; i++){ //ith point in the element if (surfElemL(n,i,1) == 1){ //if a contributing node ni = surfElemL(n,i,0); for (int m=0; m<meshOrderL+1; m++){ //mth Lagrange poly. in mapping nm = surfElemL(n,m,0); for (int j=0; j<nStrandNode; j++){ //local gradient coefficients xnj = xn(ni,j)/(jacL(n,i,j)*(double)sum(ni)); ynj = yn(ni,j)/(jacL(n,i,j)*(double)sum(ni)); a(nm,j,0) = lsL(i,m)*ynj; a(nm,j,1) =-lsL(i,m)*xnj; }} for (int m=psp2(ni); m<psp2(ni+1); m++){ //add to coefficient array nm = psp1(m); for (int j=0; j<nStrandNode; j++){ gx(m,j,0) += a(nm,j,0); gx(m,j,1) += a(nm,j,1); }} for (int m=0; m<meshOrderL+1; m++){ //reset helper array to zero nm = surfElemL(n,m,0); for (int j=0; j<nStrandNode; j++){ a(nm,j,0) = 0.; a(nm,j,1) = 0.; }}}} // clean up sum.deallocate(); a.deallocate(); surfElemL.deallocate(); elemLocalL.deallocate(); xsL.deallocate(); ysL.deallocate(); ss.deallocate(); lc.deallocate(); lsL.deallocate(); }
void Tri2dFCBlockSolver::gradSetupQuadratic() { // form quadratic sub elements int nElemQ = 3*nElem; int nneQ = 6; //quadratic elements int nngQ = 4; //quadratic elements Array2D<int> elemQ(nElemQ,nneQ),gNode(nElemQ,nngQ); int m=0; for (int n=0; n<nElem; n++){ elemQ(m ,0) = elem(n,0); elemQ(m ,1) = elem(n,4); elemQ(m ,2) = elem(n,7); elemQ(m ,3) = elem(n,3); elemQ(m ,4) = elem(n,9); elemQ(m ,5) = elem(n,8); gNode(m ,0) = 0; gNode(m ,1) = 3; gNode(m ,2) = 4; gNode(m++,3) = 5; elemQ(m ,0) = elem(n,3); elemQ(m ,1) = elem(n,1); elemQ(m ,2) = elem(n,6); elemQ(m ,3) = elem(n,4); elemQ(m ,4) = elem(n,5); elemQ(m ,5) = elem(n,9); gNode(m ,0) = 1; gNode(m ,1) = 4; gNode(m ,2) = 5; gNode(m++,3) = 3; elemQ(m ,0) = elem(n,8); elemQ(m ,1) = elem(n,5); elemQ(m ,2) = elem(n,2); elemQ(m ,3) = elem(n,9); elemQ(m ,4) = elem(n,6); elemQ(m ,5) = elem(n,7); gNode(m ,0) = 2; gNode(m ,1) = 5; gNode(m ,2) = 3; gNode(m++,3) = 4; } /* for (int n=0; n<nElemQ; n++){ cout << n << " "; for (int j=0; j<nneQ; j++) cout << elemQ(n,j) << " "; cout << endl; } exit(0); */ // Jacobian terms Array2D <double> xr(nElemQ,nngQ),yr(nElemQ,nngQ),xs(nElemQ,nngQ), ys(nElemQ,nngQ),jac(nElemQ,nngQ),rs(nneQ,3),lc(nneQ,nneQ); xr.set(0.); yr.set(0.); xs.set(0.); ys.set(0.); jac.set(0.); int orderE=2; //quadratic elements solutionPoints(orderE, spacing, &rs(0,0)); bool test=true; lagrangePoly(test, orderE, &rs(0,0), &lc(0,0)); int j,km,lm; double lrm,lsm,ri,si; for (int n=0; n<nElemQ; n++){ // evaluate the Jacobian terms at the mesh points for (int i=0; i<nngQ; i++){ //ith mesh point ri = rs(gNode(n,i),0); si = rs(gNode(n,i),1); for (int m=0; m<nneQ; m++){ //mth Lagrange polynomial j = 0; lrm = 0.; lsm = 0.; for (int k=0; k<=orderE; k++) for (int l=0; l<=orderE-k; l++){ km = max(0,k-1); lm = max(0,l-1); lrm +=((double)k)*pow(ri,km)*pow(si,l )*lc(m,j ); lsm +=((double)l)*pow(ri,k )*pow(si,lm)*lc(m,j++); } xr(n,i) += lrm*x(elemQ(n,m),0); yr(n,i) += lrm*x(elemQ(n,m),1); xs(n,i) += lsm*x(elemQ(n,m),0); ys(n,i) += lsm*x(elemQ(n,m),1); } jac(n,i) = xr(n,i)*ys(n,i)-yr(n,i)*xs(n,i); }} // lr(i,j) = (dl_j/dr)_i (a row is all Lagrange polynomials (derivatives) // evaluated at a single mesh point i, same with the other derivatives) Array2D<double> lr(nneQ,nneQ),ls(nneQ,nneQ),lrr(nneQ,nneQ), lss(nneQ,nneQ),lrs(nneQ,nneQ); lr.set(0.); ls.set(0.); lrr.set(0.); lss.set(0.); lrs.set(0.); int kmm,lmm; for (int n=0; n<nneQ; n++) // nth Lagrange polynomial for (int i=0; i<nneQ; i++){ // ith mesh point j = 0; ri = rs(i,0); si = rs(i,1); for (int k=0; k<=orderE; k++) for (int l=0; l<=orderE-k; l++){ km = max(0,k-1); lm = max(0,l-1); kmm = max(0,k-2); lmm = max(0,l-2); lr (i,n) +=((double)k)*pow(ri,km)*pow(si,l )*lc(n,j); ls (i,n) +=((double)l)*pow(ri,k )*pow(si,lm)*lc(n,j); lrr(i,n) +=((double)(k*km))*pow(ri,kmm)*pow(si,l )*lc(n,j ); lss(i,n) +=((double)(l*lm))*pow(ri,k )*pow(si,lmm)*lc(n,j ); lrs(i,n) +=((double)(k*l ))*pow(ri,km )*pow(si,lm )*lc(n,j++); }} // compute averaged quadratic FEM gradient coefficients Array1D<double> sumj(nNode); sumj.set(0.); for (int n=0; n<nElemQ; n++) for (int i=0; i<nngQ; i++){ m = gNode(n,i); sumj(elemQ(n,m)) += jac(n,i); } for (int n=0; n<nNode; n++) sumj(n) = 1./sumj(n); int k1,k2; double xri,yri,xsi,ysi; Array2D<double> ax(nNode,2); ax.set(0.); gxQ.set(0.); for (int n=0; n<nElemQ; n++) for (int i=0; i<nngQ; i++){ m = gNode(n,i); k1 = elemQ(n,m); xri = xr(n,i); yri = yr(n,i); xsi = xs(n,i); ysi = ys(n,i); for (int j=0; j<nneQ; j++){ k2 = elemQ(n,j); ax(k2,0) = lr(m,j)*ysi-ls(m,j)*yri; ax(k2,1) =-lr(m,j)*xsi+ls(m,j)*xri; } for(int j=psp2(k1); j<psp2(k1+1); j++){ k2 = psp1(j); gxQ(j,0) += ax(k2,0); gxQ(j,1) += ax(k2,1); } for (int j=0; j<nneQ; j++){ k2 = elemQ(n,j); ax(k2,0) = 0.; ax(k2,1) = 0.; }} for (int n=0; n<nNode; n++) for (int i=psp2(n); i<psp2(n+1); i++){ gxQ(i,0) *= sumj(n); gxQ(i,1) *= sumj(n); } // deallocate work arrays elemQ.deallocate(); gNode.deallocate(); xr.deallocate(); yr.deallocate(); xs.deallocate(); ys.deallocate(); jac.deallocate(); rs.deallocate(); lc.deallocate(); lr.deallocate(); ls.deallocate(); lrr.deallocate(); lss.deallocate(); lrs.deallocate(); sumj.deallocate(); ax.deallocate(); }
void Tri2dFCBlockSolver::gradient(const int& nqp, const double* p, double* px) { for (int n=0; n<nNode*nqp*2; n++) px[n] = 0.; if (order == 2){ //Green-Gauss gradients int n1,n2,k1,k2,k1x,k1y,k2x,k2y,m=0; double Ax,Ay,a,third=1./3.; for (int n=0; n<nEdge; n++){ //interior edges n1 = edge(n,0); n2 = edge(n,1); Ax = area(n,0); Ay = area(n,1); k1 = n1*nqp; k2 = n2*nqp; k1x = n1*nqp*2; k1y = k1x+nqp; k2x = n2*nqp*2; k2y = k2x+nqp; for (int k=0; k<nqp; k++){ a = p[k1+k]+p[k2+k]; px[k1x+k] += Ax*a; px[k1y+k] += Ay*a; px[k2x+k] -= Ax*a; px[k2y+k] -= Ay*a; }} for (int n=nEdge-nEdgeBd; n<nEdge; n++){ //boundary edges n1 = edge(n,0); n2 = edge(n,1); Ax = areaBd(m ,0); Ay = areaBd(m++,1); k1 = n1*nqp; k2 = n2*nqp; k1x = n1*nqp*2; k1y = k1x+nqp; k2x = n2*nqp*2; k2y = k2x+nqp; for (int k=0; k<nqp; k++){ a =(5.*p[k1+k]+p[k2+k])*third; px[k1x+k] += Ax*a; px[k1y+k] += Ay*a; a =(p[k1+k]+5.*p[k2+k])*third; px[k2x+k] += Ax*a; px[k2y+k] += Ay*a; }} for (int n=0; n<nNode; n++){ //normalize gradients a = .5/v(n); k1 = n*nqp*2; for (int k=0; k<nqp*2; k++) px[k1+k] *= a; }} else if (order == 3){ //FEM gradients int k1x,k1y,k2,k3; double dx,dy; for (int n=0; n<nNode; n++){ k1x = n*nqp*2; k1y = k1x+nqp; for(int i=psp2(n); i<psp2(n+1); i++){ k2 = psp1(i)*nqp; dx = gx(i,0); dy = gx(i,1); for (int k=0; k<nqp; k++){ k3 = k2+k; px[k1x+k] += p[k3]*dx; px[k1y+k] += p[k3]*dy; }}}} }
int main(int argc, char* argv[]) { /*survey parameters*/ int nx, nz; float dx, dz; int n_srcs=1; 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, adj; float vref; bool born; pspar par; int nx1, nz1; /*domain of interest*/ float *vel,***dat,***dat_v,**wvfld1,**wvfld,*img,*imgs; /*velocity profile*/ sf_file Fi,Fo,Fv,Fd_v,snaps; /* I/O files */ sf_axis az,ax; /* cube axes */ int shtbgn,shtend,shtnum,shtint; int ix,iz,is,which; bool justrec; bool diff; sf_file Fi1; float ***dat1; sf_init(argc,argv); if (!sf_getint("snap",&snap)) snap=0; /* interval for snapshots */ if (!sf_getbool("cmplx",&cmplx)) cmplx=true; /* use complex fft */ if (!sf_getint("pad1",&pad1)) pad1=1; /* padding factor on the first axis */ if(!sf_getbool("abc",&abc)) abc=false; /* absorbing flag */ if(!sf_getbool("born",&born)) born=false; /* born modeling flag */ if(!sf_getbool("diff",&diff)) diff=false; /* diffraction imaging flag */ if(!sf_getbool("justrec",&justrec)) justrec=false; /* just need full waveform record (no born or rtdm) */ if (abc) { if(!sf_getint("nbt",&nbt)) sf_error("Need nbt!"); if(!sf_getint("nbb",&nbb)) nbb = nbt; if(!sf_getint("nbl",&nbl)) nbl = nbt; if(!sf_getint("nbr",&nbr)) nbr = nbt; if(!sf_getfloat("ct",&ct)) sf_error("Need ct!"); if(!sf_getfloat("cb",&cb)) cb = ct; if(!sf_getfloat("cl",&cl)) cl = ct; if(!sf_getfloat("cr",&cr)) cr = ct; } else { nbt = 0; nbb = 0; nbl = 0; nbr = 0; ct = 0; cb = 0; cl = 0; cr = 0; } if (!sf_getbool("verb",&verb)) verb=false; /* verbosity */ if (!sf_getbool("ps",&ps)) ps=false; /* use pseudo-spectral */ if (ps) sf_warning("Using pseudo-spectral..."); else sf_warning("Using pseudo-analytical..."); if (!sf_getbool("adj",&adj)) adj=false; /* use pseudo-spectral */ if (justrec && adj) sf_error("No migration in justrec mode!"); if (adj) sf_warning("RTM"); else sf_warning("RTDM"); if (!sf_getfloat("vref",&vref)) vref=1500; /* reference velocity (default using water) */ /* setup I/O files */ Fi = sf_input ("in"); Fo = sf_output("out"); Fv = sf_input("vel"); if (adj) { gpl = -1; gpl_v = -1; sf_histint(Fi,"n1",&nt); sf_histfloat(Fi,"d1",&dt); sf_histint(Fi,"n2",&gpl); if (NULL!=sf_getstring("dat_v")) { Fd_v = sf_input("dat_v"); sf_histint(Fd_v,"n2",&gpl_v); } else Fd_v = NULL; if (diff) Fi1 = sf_input("dat_2"); else Fi1 = NULL; } else { if (!sf_getint("nt",&nt)) sf_error("Need nt!"); if (!sf_getfloat("dt",&dt)) sf_error("Need dt!"); if (!sf_getint("gpl",&gpl)) gpl = -1; /* geophone length */ if (!sf_getint("gpl_v",&gpl_v)) gpl_v = -1; /* geophone height */ } if (!sf_getint("src",&src)) src=0; /* source type */ //if (!sf_getint("n_srcs",&n_srcs)) n_srcs=1; /* source type */ spx = sf_intalloc(n_srcs); spz = sf_intalloc(n_srcs); f0 = sf_floatalloc(n_srcs); t0 = sf_floatalloc(n_srcs); A = sf_floatalloc(n_srcs); //if (!sf_getints("spx",spx,n_srcs)) sf_error("Need spx!"); /* shot position x */ if (!sf_getints("spz",spz,n_srcs)) sf_error("Need spz!"); /* shot position z */ if (!sf_getfloats("f0",f0,n_srcs)) sf_error("Need f0! (e.g. 30Hz)"); /* wavelet peak freq */ if (!sf_getfloats("t0",t0,n_srcs)) sf_error("Need t0! (e.g. 0.04s)"); /* wavelet time lag */ if (!sf_getfloats("A",A,n_srcs)) sf_error("Need A! (e.g. 1)"); /* wavelet amplitude */ if (!sf_getint("shtbgn", &shtbgn)) sf_error("Need shot starting location on grid!"); if (!sf_getint("shtend", &shtend)) sf_error("Need shot ending location on grid!"); if (!sf_getint("shtint", &shtint)) sf_error("Need shot interval on grid!"); shtnum = (int)((shtend-shtbgn)/shtint) + 1; if (!sf_getint("which", &which)) which = 0; if (!sf_getint("gpx",&gpx)) gpx = -1; /* geophone position x */ if (!sf_getint("gpz",&gpz)) gpz = -1; /* geophone position z */ if (!sf_getint("gpx_v",&gpx_v)) gpx_v = -1; /* geophone position x */ if (!sf_getint("gpz_v",&gpz_v)) gpz_v = -1; /* geophone position z */ if (SF_FLOAT != sf_gettype(Fv)) sf_error("Need float input"); /* Read/Write axes */ az = sf_iaxa(Fv,1); nz = sf_n(az); dz = sf_d(az); ax = sf_iaxa(Fv,2); nx = sf_n(ax); dx = sf_d(ax); nz1 = nz-nbt-nbb; nx1 = nx-nbl-nbr; if (gpx==-1) gpx = nbl; if (gpz==-1) gpz = nbt; if (gpl==-1) gpl = nx1; if (gpx_v==-1) gpx_v = nbl; if (gpz_v==-1) gpz_v = nbt; if (gpl_v==-1) gpl_v = nz1; if (adj) { /*output image*/ sf_setn(az,nz1); sf_setn(ax,nx1); sf_oaxa(Fo,az,1); sf_oaxa(Fo,ax,2); sf_putint(Fo,"n3",1); sf_putfloat(Fo,"d3",shtint*dx); sf_putfloat(Fo,"o3",0.); sf_settype(Fo,SF_FLOAT); } else { /*output data*/ sf_setn(ax,gpl); /*output horizontal data is mandatory*/ sf_putint(Fo,"n1",nt); sf_putfloat(Fo,"d1",dt); sf_putfloat(Fo,"o1",0.); sf_putstring(Fo,"label1","Time"); sf_putstring(Fo,"unit1","s"); sf_oaxa(Fo,ax,2); sf_putint(Fo,"n3",shtnum); sf_putfloat(Fo,"d3",shtint*dx); sf_putfloat(Fo,"o3",0.); sf_putstring(Fo,"label3","Shot"); sf_settype(Fo,SF_FLOAT); /*output vertical data is optional*/ if (NULL!=sf_getstring("dat_v")) { Fd_v = sf_output("dat_v"); sf_setn(ax,gpl_v); /*output horizontal data is mandatory*/ sf_putint(Fd_v,"n1",nt); sf_putfloat(Fd_v,"d1",dt); sf_putfloat(Fd_v,"o1",0.); sf_putstring(Fd_v,"label1","Time"); sf_putstring(Fd_v,"unit1","s"); sf_oaxa(Fd_v,ax,2); sf_putint(Fd_v,"n3",shtnum); sf_putfloat(Fd_v,"d3",shtint*dx); sf_putfloat(Fd_v,"o3",0.); sf_putstring(Fd_v,"label3","Shot"); sf_settype(Fd_v,SF_FLOAT); } else Fd_v = NULL; } if (snap > 0) { snaps = sf_output("snaps"); /* (optional) snapshot file */ sf_setn(az,nz1); sf_setn(ax,nx1); sf_oaxa(snaps,az,1); sf_oaxa(snaps,ax,2); sf_putint(snaps,"n3",nt/snap); sf_putfloat(snaps,"d3",dt*snap); sf_putfloat(snaps,"o3",0.); sf_putstring(snaps,"label3","Time"); sf_putstring(snaps,"unit3","s"); } else snaps = NULL; par = (pspar) sf_alloc(1,sizeof(*par)); vel = sf_floatalloc(nz*nx); dat = sf_floatalloc3(nt,gpl,shtnum); img = sf_floatalloc(nz1*nx1); if (adj) { imgs= sf_floatalloc(nz1*nx1); if (adj) { for (ix=0; ix<nx1; ix++) for (iz=0; iz<nz1; iz++) imgs[ix*nz1+iz] = 0.; } } else imgs = NULL; if (NULL!=Fd_v) dat_v = sf_floatalloc3(nt,gpl_v,shtnum); else dat_v = NULL; if (snap>0) { wvfld1 = sf_floatalloc2(nx1*nz1,nt/snap); wvfld = sf_floatalloc2(nx1*nz1,nt/snap); } else { wvfld1 = NULL; wvfld = NULL; } if (adj && diff) dat1 = sf_floatalloc3(nt,gpl,shtnum); else dat1 = NULL; sf_floatread(vel,nz*nx,Fv); if (adj) { sf_floatread(dat[0][0],gpl*nt*shtnum,Fi); if (NULL!=Fd_v) sf_floatread(dat_v[0][0],gpl_v*nt*shtnum,Fd_v); if (diff) sf_floatread(dat1[0][0],gpl_v*nt*shtnum,Fi1); } else { sf_floatread(img,nz1*nx1,Fi); } /*passing the parameters*/ par->nx = nx; par->nz = nz; par->dx = dx; par->dz = dz; par->n_srcs= n_srcs; par->spx = spx; par->spz = spz; par->gpz = gpz; par->gpx = gpx; par->gpl = gpl; par->gpz_v = gpz_v; par->gpx_v = gpx_v; par->gpl_v = gpl_v; par->snap = snap; par->cmplx = cmplx; par->pad1 = pad1; par->abc = abc; par->nbt = nbt; par->nbb = nbb; par->nbl = nbl; par->nbr = nbr; par->ct = ct; par->cb = cb; par->cl = cl; par->cr = cr; par->src = src; par->nt = nt; par->dt = dt; par->f0 = f0; par->t0 = t0; par->A = A; par->verb = verb; par->ps = ps; par->vref = vref; for (is=0; is<shtnum; is++){ *spx = shtbgn + shtint*is; //par->spx = spx; //pointer sf_warning("Processing shot # %d/%d",is,shtnum-1); if (adj && diff) { sf_warning("Simultaneously propagating two receiver wavefields..."); psp3(wvfld, wvfld1, dat[is], dat1[is], img, vel, par); for (ix=0; ix<nx1; ix++) for (iz=0; iz<nz1; iz++) imgs[ix*nz1+iz] += img[ix*nz1+iz]; } else { if (justrec) { if (NULL == dat_v) psp(wvfld, dat[is], NULL, NULL, vel, par, false); else psp(wvfld, dat[is], dat_v[is], NULL, vel, par, false); } else { sf_warning("Computing source wavefield ..."); psp(wvfld1, NULL, NULL, NULL, vel, par, false); if (born) dt2v2(wvfld1, vel, par); sf_warning("Computing receiver wavefield ..."); if (NULL == dat_v) psp2(wvfld1, wvfld, dat[is], NULL, img, vel, par, adj); else psp2(wvfld1, wvfld, dat[is], dat_v[is], img, vel, par, adj); if (adj) { for (ix=0; ix<nx1; ix++) for (iz=0; iz<nz1; iz++) imgs[ix*nz1+iz] += img[ix*nz1+iz]; } } } if (snap>0 && is==which) sf_floatwrite(wvfld[0],nz1*nx1*nt/snap,snaps); } if (adj) { sf_floatwrite(imgs,nz1*nx1,Fo); } else { sf_floatwrite(dat[0][0],gpl*nt*shtnum,Fo); if (NULL!=Fd_v) sf_floatwrite(dat_v[0][0],gpl_v*nt*shtnum,Fd_v); } exit (0); }