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);
}
