void decodeReflectors (int *nrPtr,
float **aPtr, int **nxzPtr, float ***xPtr, float ***zPtr)
/*************************************************************************
decodeReflectors - parse reflectors parameter string
**************************************************************************
Output:
nrPtr pointer to nr an int specifying number of reflectors
aPtr pointer to a specifying reflector amplitudes
nxzPtr pointer to nxz specifying number of (x,z) pairs defining the
reflectors
xPtr pointer to array[x][nr] of x values for the entire model
zPtr array[z][nr] of z values for the entire model
***************************************************************************
Author: Dave Hale, Colorado School of Mines, 09/17/91
**************************************************************************/
{
int nr,*nxz,ir;
float *a,**x,**z;
char t[1024],*s;
/* count reflectors */
nr = countparname("ref");
if (nr==0) nr = 1;
/* allocate space */
a = ealloc1(nr,sizeof(float));
nxz = ealloc1(nr,sizeof(int));
x = ealloc1(nr,sizeof(float*));
z = ealloc1(nr,sizeof(float*));
/* get reflectors */
for (ir=0; ir<nr; ++ir) {
if (!getnparstring(ir+1,"ref",&s)) s = "1:1,2;4,2";
strcpy(t,s);
if (!decodeReflector(t,&a[ir],&nxz[ir],&x[ir],&z[ir]))
err("Reflector number %d specified "
"incorrectly!\n",ir+1);
}
/* set output parameters before returning */
*nrPtr = nr;
*aPtr = a;
*nxzPtr = nxz;
*xPtr = x;
*zPtr = z;
}
main(int argc, char **argv)
{
char *s;
short h, vh[N];
unsigned short u, vu[N];
long l, vl[N];
unsigned long v, vv[N];
int i, vi[N], ipar, npar, nval;
unsigned int p, vp[N];
float f, vf[N];
double d, vd[N];
initargs(argc, argv);
/* int parameters */
npar = countparname("i");
printf("\nnumber of i pars = %d\n",npar);
for (ipar=1; ipar<=npar; ++ipar) {
getnparint(ipar,"i",&i);
printf("occurence %d of i=%d\n",ipar,i);
}
if (getparint("i", &i))
printf("last occurence of i=%d\n",i);
npar = countparname("vi");
printf("number of vi pars = %d\n",npar);
for (ipar=1; ipar<=npar; ++ipar) {
nval = countnparval(ipar,"vi");
printf("occurence %d has %d values\n",ipar,nval);
nval = getnparint(ipar,"vi",vi);
printf("vi=");
for (i=0; i<nval; i++)
printf("%d%c",vi[i],i==nval-1?'\n':',');
}
if (npar>0) {
nval = countparval("vi");
printf("last occurence has %d values\n",nval);
getparint("vi",vi);
printf("vi=");
for (i=0; i<nval; i++)
printf("%d%c",vi[i],i==nval-1?'\n':',');
}
/* float parameters */
npar = countparname("f");
printf("\nnumber of f pars = %d\n",npar);
for (ipar=1; ipar<=npar; ++ipar) {
getnparfloat(ipar,"f",&f);
printf("occurence %d of f=%g\n",ipar,f);
}
if (getparfloat("f", &f))
printf("last occurence of f=%g\n",f);
npar = countparname("vf");
printf("number of vf pars = %d\n",npar);
for (ipar=1; ipar<=npar; ++ipar) {
nval = countnparval(ipar,"vf");
printf("occurence %d has %d values\n",ipar,nval);
nval = getnparfloat(ipar,"vf",vf);
printf("vf=");
for (i=0; i<nval; i++)
printf("%g%c",vf[i],i==nval-1?'\n':',');
}
if (npar>0) {
nval = countparval("vf");
printf("last occurence has %d values\n",nval);
getparfloat("vf",vf);
printf("vf=");
for (i=0; i<nval; i++)
printf("%g%c",vf[i],i==nval-1?'\n':',');
}
/* string parameters */
npar = countparname("s");
printf("\nnumber of s pars = %d\n",npar);
for (ipar=1; ipar<=npar; ++ipar) {
getnparstring(ipar,"s",&s);
printf("occurence %d of s=%s\n",ipar,s);
}
if (getparstring("s", &s))
printf("last occurence of s=%s\n",s);
if( auxgetpar("aux","i","i",&i) )
printf("in aux last occurence of i=%d\n",i);
if( auxgetpar("aux","f","f",&f) )
printf("in aux last occurence of f=%f\n",f);
if( auxgetpar("aux","s","s",&s) )
printf("in aux last occurence of s=%s\n",s);
if (getparint("i", &i))
printf("last occurence of i=%d\n",i);
if( auxgetpar("aux","junk","s",&s) )
printf("in aux last occurence of junk=%s\n",s);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
usghed usghin, usghtop, usghbot, usghlayer;
usghed usghvtop, usghvbot, usghglayer;
FILE *infp,*outfp,*topfp,*botfp,*layerfp;
FILE *vtopfp,*vbotfp,*glayerfp;
char *infile,*outfile,*layertop, *layerbot;
char *gtopgrid, *gbotgrid;
char *layers, *glayers;
int ibot, itop;
int ierr;
int nz, iz;
float *dzrl, sm2top, sm2bot, sm3top, sm3bot;
float gabovetop, gbelowbot;
int igabovetop, igbelowbot;
float g0, r0;
int ginterp=0;
int n1,n2,n3;
int i1,i2,i3;
float d1,o1,d2,d3;
float *grid, *ztop, *zbot, gmin, gmax;
float *vtop, *vbot;
float top, bot;
float tmp;
int i1top, i1bot, itmp;
int ivtop, ivbot;
float *sm2s, *sm3s;
float *work, *fsmx, *fsmy, *vs, *zs;
float z, scale, zscale, vscale;
int ismx, ismy;
int nlayer, nglayer;
/* hook up getpar */
initargs(argc,argv);
askdoc(0);
/* get parameters */
if(getparstring("infile",&infile)) {
infp = efopen(infile,"r");
} else {
infp = stdin;
}
ierr = fgetusghdr(infp,&usghin);
if(ierr!=0) err(" input grid header error ");
if(getparstring("outfile",&outfile)) {
outfp = efopen(outfile,"w");
} else {
outfp = stdout;
}
file2g(infp);
file2g(outfp);
nlayer = 0;
nglayer = 0;
nlayer = countparname("layers");
if(nlayer==1) err(" at least 2 layers are needed \n");
nglayer = countparname("glayers");
if(nlayer==0) {
if (getparstring("layertop",&layertop)) {
topfp = efopen(layertop,"r");
ierr = fgetusghdr(topfp,&usghtop);
if(ierr!=0) err(" layertop grid header error ");
} else {
err(" layertop missing ");
}
if (getparstring("layerbot",&layerbot)) {
botfp = efopen(layerbot,"r");
ierr = fgetusghdr(botfp,&usghbot);
if(ierr!=0) err(" layerbot grid header error ");
} else {
err(" layerbot missing ");
}
} else {
if(nlayer!=nglayer && nglayer>0 )
err(" %d layers not matching %d glayers \n",nlayer,nglayer);
}
ivtop = 0;
if (getparstring("gtopgrid",>opgrid)) {
vtopfp = efopen(gtopgrid,"r");
ierr = fgetusghdr(vtopfp,&usghvtop);
if(ierr!=0) err(" gtopgrid header error ");
ivtop = 1;
}
ivbot = 0;
if(getparstring("gbotgrid",&gbotgrid) ) {
vbotfp = efopen(gbotgrid,"r");
ierr = fgetusghdr(vbotfp,&usghvbot);
if(ierr!=0) err(" gbotgrid header error ");
ivbot = 1;
}
if(!getparint("ginterp",&ginterp)) ginterp=0;
if(ivtop==0 || ivbot==0) {
if ( getparfloat("g0",&g0) && getparfloat("r0",&r0) ) {
ivtop = -1; ivbot = -1;
}
}
if( !getparint("nz",&nz) ) nz=10;
if(nlayer!=0) nz = nlayer - 1;
dzrl = emalloc(nz*sizeof(float));
sm2s = emalloc((nz+1)*sizeof(float));
sm3s = emalloc((nz+1)*sizeof(float));
if( countparval("dzrl")>0 && nz!=countparval("dzrl") ) {
err( " number of dzrl elements must match nz=%d \n",nz);
} else if( countparval("dzrl")==0 ) {
for(iz=0;iz<nz;iz++) dzrl[iz] = 1.;
} else if( countparval("dzrl")==nz) {
getparfloat("dzrl",dzrl);
}
if( !getparfloat("sm2top",&sm2top) ) sm2top=0.;
if( !getparfloat("sm3top",&sm3top) ) sm3top=0.;
if( !getparfloat("sm2bot",&sm2bot) ) sm2bot=0.;
if( !getparfloat("sm3bot",&sm3bot) ) sm3bot=0.;
igabovetop = 1;
if( !getparfloat("gabovetop",&gabovetop) ) igabovetop=0;
igbelowbot = 1;
if( !getparfloat("gbelowbot",&gbelowbot) ) igbelowbot=0;
n1 = usghin.n1;
n2 = usghin.n2;
n3 = usghin.n3;
o1 = usghin.o1;
d1 = usghin.d1;
d2 = usghin.d2;
d3 = usghin.d3;
gmin = usghin.gmin;
gmax = usghin.gmax;
/* memory allocations */
ztop = (float*) emalloc(n2*n3*sizeof(float));
zbot = (float*) emalloc(n2*n3*sizeof(float));
vtop = (float*) emalloc(n2*n3*sizeof(float));
vbot = (float*) emalloc(n2*n3*sizeof(float));
zs = (float*) emalloc(n2*n3*(nz+1)*sizeof(float));
vs = (float*) emalloc(n2*n3*(nz+1)*sizeof(float));
work = (float*) emalloc(n2*n3*sizeof(float));
grid = (float*) emalloc(n1*sizeof(float));
if(nlayer==0) {
if(usghin.n2!=usghtop.n1) err("check layertop header n1");
if(usghin.n3!=usghtop.n2) err("check layertop header n2");
if(usghin.o2!=usghtop.o1) err("check layertop header o1");
if(usghin.o3!=usghtop.o2) err("check layertop header o2");
if(usghin.d2!=usghtop.d1) err("check layertop header d1");
if(usghin.d3!=usghtop.d2) err("check layertop header d2");
efseek(topfp,0,0);
efread(ztop,sizeof(float),n2*n3,topfp);
if(usghin.n2!=usghbot.n1) err("check layerbot header n1");
if(usghin.n3!=usghbot.n2) err("check layerbot header n2");
if(usghin.o2!=usghbot.o1) err("check layerbot header o1");
if(usghin.o3!=usghbot.o2) err("check layerbot header o2");
if(usghin.d2!=usghbot.d1) err("check layerbot header d1");
if(usghin.d3!=usghbot.d2) err("check layerbot header d2");
efseek(botfp,0,0);
efread(zbot,sizeof(float),n2*n3,botfp);
if(ivtop==1) {
if(usghin.n2!=usghvtop.n1) err("check gtopgrid header n1");
if(usghin.n3!=usghvtop.n2) err("check gtopgrid header n2");
if(usghin.o2!=usghvtop.o1) err("check gtopgrid header o1");
if(usghin.o3!=usghvtop.o2) err("check gtopgrid header o2");
if(usghin.d2!=usghvtop.d1) err("check gtopgrid header d1");
if(usghin.d3!=usghvtop.d2) err("check gtopgrid header d2");
efseek(vtopfp,0,0);
efread(vtop,sizeof(float),n2*n3,vtopfp);
}
if(ivbot==1) {
if(usghin.n2!=usghvbot.n1) err("check gbotgrid header n1");
if(usghin.n3!=usghvbot.n2) err("check gbotgrid header n2");
if(usghin.o2!=usghvbot.o1) err("check gbotgrid header o1");
if(usghin.o3!=usghvbot.o2) err("check gbotgrid header o2");
if(usghin.d2!=usghvbot.d1) err("check gbotgrid header d1");
if(usghin.d3!=usghvbot.d2) err("check gbotgrid header d2");
efseek(vbotfp,0,0);
efread(vbot,sizeof(float),n2*n3,vbotfp);
}
} else {
for(iz=0;iz<nlayer;iz++) {
getnparstring(iz+1,"layers",&layers);
layerfp=efopen(layers,"r");
ierr = fgetusghdr(layerfp,&usghlayer);
if(ierr!=0) err(" error open layers=%s \n",layers);
if(usghin.n2!=usghlayer.n1) err("check %s header n1",layers);
if(usghin.n3!=usghlayer.n2) err("check %s header n2",layers);
if(usghin.o2!=usghlayer.o1) err("check %s header o1",layers);
if(usghin.o3!=usghlayer.o2) err("check %s header o2",layers);
if(usghin.d2!=usghlayer.d1) err("check %s header d1",layers);
if(usghin.d3!=usghlayer.d2) err("check %s header d2",layers);
efseek(layerfp,0,0);
efread(zs+iz*n2*n3,sizeof(float),n2*n3,layerfp);
efclose(layerfp);
}
for(iz=0;iz<nglayer;iz++) {
getnparstring(iz+1,"glayers",&glayers);
glayerfp=efopen(glayers,"r");
ierr = fgetusghdr(glayerfp,&usghglayer);
if(ierr!=0) err(" error open layers=%s \n",layers);
if(usghin.n2!=usghglayer.n1) err("check %s header n1",glayers);
if(usghin.n3!=usghglayer.n2) err("check %s header n2",glayers);
if(usghin.o2!=usghglayer.o1) err("check %s header o1",glayers);
if(usghin.o3!=usghglayer.o2) err("check %s header o2",glayers);
if(usghin.d2!=usghglayer.d1) err("check %s header d1",glayers);
if(usghin.d3!=usghglayer.d2) err("check %s header d2",glayers);
efseek(glayerfp,0,0);
efread(vs+iz*n2*n3,sizeof(float),n2*n3,glayerfp);
efclose(glayerfp);
}
nz = nlayer - 1;
}
/* compute mini layer depth and grid values */
if(nlayer==0) {
for(i2=0;i2<n2*n3;i2++) {
zs[i2] = ztop[i2];
vs[i2] = vtop[i2];
}
tmp = 0.;
for(iz=0;iz<nz;iz++) tmp = tmp + dzrl[iz];
vscale = 0.;
zscale = 0.;
for(iz=1;iz<nz;iz++) {
zscale += dzrl[iz-1]/tmp;
if(ginterp==0) {
vscale += dzrl[iz-1]/tmp;
} else {
vscale = (float)iz / nz;
}
for(i2=0;i2<n2*n3;i2++) {
zs[i2+iz*n2*n3] = ztop[i2] +
zscale*(zbot[i2]-ztop[i2]);
vs[i2+iz*n2*n3] = vtop[i2] +
vscale*(vbot[i2]-vtop[i2]);
}
}
for(i2=0;i2<n2*n3;i2++) {
zs[i2+nz*n2*n3] = zbot[i2];
vs[i2+nz*n2*n3] = vbot[i2];
}
}
/* compute smoothing window for mini layers */
tmp = 0.;
for(iz=0;iz<nz;iz++) tmp = tmp + dzrl[iz];
scale = 0.;
sm2s[0] = sm2top;
sm3s[0] = sm3top;
for(iz=1;iz<nz+1;iz++) {
scale += dzrl[iz-1]/tmp;
sm2s[iz] = sm2top + scale*(sm2bot-sm2top);
sm3s[iz] = sm3top + scale*(sm3bot-sm3top);
}
/* compute grid values at the mini layers if not specified */
fseek2g(infp,0,0);
if( ( (ivtop==0 || ivbot==0) && nlayer==0 ) || (nglayer==0 && nlayer>0) ) {
for(i3=0;i3<n3;i3++) {
for(i2=0;i2<n2;i2++) {
efread(grid,sizeof(float),n1,infp);
for(iz=0;iz<nz+1;iz++) {
tmp = (zs[i2+i3*n2+iz*n2*n3] - o1)/d1 + 0.5;
i1 = tmp;
if(i1<0) {
vs[i2+i3*n2+iz*n2*n3] = grid[0];
} else if(i1>=n1-1) {
vs[i2+i3*n2+iz*n2*n3] = grid[n1-1];
} else {
vs[i2+i3*n2+iz*n2*n3] = grid[i1]+
(tmp-i1)*(grid[i1+1]-grid[i1]);
}
}
}
}
} else if(ivtop==-1 && ivbot==-1) {
for(i3=0;i3<n3;i3++) {
for(i2=0;i2<n2;i2++) {
for(iz=0;iz<nz+1;iz++) {
tmp = (zs[i2+i3*n2+iz*n2*n3] - ztop[i3*n2+i2]);
vs[i2+i3*n2+iz*n2*n3] = g0 + r0 * tmp;
}
}
}
}
/* smooth mini layer grids */
for(iz=0;iz<nz+1;iz++) {
tmp = sm2s[iz]/d2;
ismx = tmp + 1.5;
tmp = sm3s[iz]/d3;
ismy = tmp + 1.5;
fsmx = (float*) emalloc(ismx*sizeof(float));
fsmy = (float*) emalloc(ismy*sizeof(float));
/* 2d smoothing */
smth2d_(vs+iz*n2*n3,work,fsmx,fsmy,&n2,&n3,&ismx,&ismy);
/*
dump2xplot(vs+iz*n2*n3,n2,n3,0,"vsmoth");
*/
free(fsmx);
free(fsmy);
}
/* output grid */
fseek2g(infp,0,0);
for(i3=0;i3<n3;i3++) {
for(i2=0;i2<n2;i2++) {
efread(grid,sizeof(float),n1,infp);
itmp = i2+i3*n2;
if(nlayer==0) {
top = ztop[itmp];
bot = zbot[itmp];
} else {
top = zs[itmp];
bot = zs[itmp+(nlayer-1)*n2*n3];
}
tmp = (top - o1)/d1 + 0.5;
i1top = tmp;
tmp = (bot - o1)/d1 + 0.5;
i1bot = tmp;
if(i1top<0) i1top = 0;
if(i1bot>n1-1) i1bot = n1-1;
for(i1=i1top;i1<=i1bot;i1++) {
z = o1 + i1*d1;
if(z>=zs[itmp] && z<=zs[itmp+nz*n2*n3]) {
for(iz=0;iz<nz;iz++) {
if( z == zs[itmp+iz*n2*n3] && z == zs[itmp+(iz+1)*n2*n3] ){
grid[i1] = vs[itmp+iz*n2*n3];
}else if(z>=zs[itmp+iz*n2*n3] && z<zs[itmp+(iz+1)*n2*n3]) {
tmp = (z-zs[itmp+iz*n2*n3]) /
(zs[itmp+(iz+1)*n2*n3]-zs[itmp+iz*n2*n3]);
grid[i1] = vs[itmp+iz*n2*n3] +
tmp*(vs[itmp+(iz+1)*n2*n3]-vs[itmp+iz*n2*n3]);
if( grid[i1] != grid[i1] ){
fprintf( stderr ,"NaN at i3=%d " ,i3 );
fprintf( stderr ,"i2=%d i1=%d\n" ,i2, i3);
}
break;
}
}
}
}
if(igabovetop==1) {
for(i1=0;i1<i1top;i1++) {
grid[i1] = gabovetop;
}
}
if(igbelowbot==1) {
for(i1=i1bot;i1<n1;i1++) {
grid[i1] = gbelowbot;
}
}
if(i2==0 && i3==0) {
gmin = grid[0];
gmax = grid[0];
}
for(i1=0;i1<n1;i1++) {
if(gmin>grid[i1]) gmin = grid[i1];
if(gmax<grid[i1]) gmax = grid[i1];
}
if( grid[0] != grid[0] ){
fprintf( stderr ,"NaN\n" );
}
efwrite(grid,sizeof(float),n1,outfp);
}
}
usghin.gmin = gmin;
usghin.gmax = gmax;
ierr = fputusghdr(outfp,&usghin);
free(ztop);
free(zbot);
free(vtop);
free(vbot);
free(zs);
free(vs);
free(work);
free(grid);
exit(0);
}
main(int argc,char *argv[]) {
int mergeaxis, nin, headupdate;
int i, nread;
string *datain;
FILE *outfp = stdout;
FILE **infp;
char *grid, *grido;
usghed usgh, usgh2;
int ierr;
int n1, n2, n3, n4, n5;
int i1, i2, i3, i4, i5;
int si3, ni3=0, si5, ni5=0;
int nn3=1, nn5=1, ii5;
int i50;
long long lpos;
int n1out;
float ddupdate;
int iddupdate=1;
int *m5;
initargs(argc,argv) ;
askdoc(1);
if( !getparint("mergeaxis",&mergeaxis) ) mergeaxis=5;
if( !getparint("headupdate",&headupdate) ) headupdate=5;
if( !getparfloat("ddupdate",&ddupdate) ) {
iddupdate = 0;
}
file2g(outfp);
nin = countparname("gridin");
fprintf(stderr," gridmerge with %d input grid files \n",nin);
datain = (string *) malloc(nin*sizeof(string));
infp = (FILE**) malloc(nin*sizeof(FILE *));
for(i=0;i<nin;i++) {
getnparstring(i+1,"gridin",&datain[i]);
fprintf(stderr," Input %d : gridin=%s \n",i+1,datain[i]);
/*
if((infp[i] = fopen(datain[i],"r"))==NULL)
err(" %s not found ",datain[i]);
*/
infp[i] = fopen(datain[i],"r");
file2g(infp[i]);
}
ierr = fgetusghdr(infp[0],&usgh);
if(ierr!=0) err(" error open gridin=%s \n",datain[0]);
grid = (char*)malloc(usgh.n1*usgh.dtype);
m5 = (int*)malloc(nin*sizeof(int));
if( !getparint("si3",&si3) ) si3=1;
if( !getparint("si5",&si5) ) si5=1;
if( !getparint("ni3",&ni3) ) { ni3=0; nn3=0; }
if( !getparint("ni5",&ni5) ) { ni5=0; nn5=0; }
si3 = si3 - 1;
si5 = si5 - 1;
if(mergeaxis==5) {
n5 = 0;
ii5 = 0;
for(i=0;i<nin;i++) {
ierr = fgetusghdr(infp[i],&usgh2);
if(ierr!=0) err(" error open gridin=%s \n",datain[i]);
if(usgh.n1*usgh.n2*usgh.n3*usgh.n4
!=usgh2.n1*usgh2.n2*usgh2.n3*usgh2.n4)
err(" check gridin=%s \n",datain[i]);
n5 += usgh2.n5;
fseek64(infp[i],0,0);
nread = usgh2.n5 * usgh2.n4 * usgh2.n3 *usgh2.n2;
if(nn3==0) ni3 = usgh2.n3;
if(nn5==0) ni5 += usgh2.n5;
fprintf(stderr," ii5=%d si5=%d ni5=%d \n",ii5+1,si5+1,ni5);
fprintf(stderr," si3=%d ni3=%d \n",si3+1,ni3);
if(ii5+usgh2.n5<=si5) {
ii5 = ii5 + usgh2.n5;
fprintf(stderr," skip gridin=%s ... o5=%g n5=%d d5=%g \n",
datain[i],usgh2.o5,usgh2.n5,usgh2.d5);
} else {
if(ii5>=ni5) {
ii5 = ii5 + usgh2.n5;
break;
}
i50 = si5 - ii5;
if(i50>0) {
lpos = i50*usgh2.n1*usgh2.n2;
lpos = lpos*usgh2.n3*usgh2.n4*usgh2.dtype;
fseek64(infp[i],lpos,0);
ii5 = si5;
} else {
i50 = 0;
}
for(i5=i50;i5<usgh2.n5;i5++) {
for(i4=0;i4<usgh2.n4;i4++) {
if(si3>=0) {
lpos = si3+(i4+i5*usgh2.n4)*usgh2.n3;
lpos = lpos*usgh2.n2*usgh2.n1*usgh2.dtype;
fseek64(infp[i],lpos,0);
}
for(i3=si3;i3<ni3;i3++) {
for(i2=0;i2<usgh2.n2;i2++) {
fread(grid,usgh.dtype,usgh.n1,infp[i]);
fwrite(grid,usgh.dtype,usgh.n1,outfp);
}
}
}
ii5 = ii5 + 1;
if(ii5>=ni5 && nn5>0) {
ii5 = ii5 + (usgh2.n5-i5);
break;
}
}
fprintf(stderr," merge gridin=%s ... o5=%g n5=%d d5=%g \n",
datain[i],usgh2.o5,usgh2.n5,usgh2.d5);
}
}
usgh.o3 = si3 * usgh.d3 + usgh.o3;
usgh.n3 = (ni3 - si3);
usgh.o5 = si5 * usgh.d5 + usgh.o5;
usgh.n5 = (ni5 - si5);
} else if(mergeaxis==4) {
n4 = 0;
for(i=0;i<nin;i++) {
ierr = fgetusghdr(infp[i],&usgh2);
if(ierr!=0) err(" error open gridin=%s \n",datain[i]);
if(usgh.n1*usgh.n2*usgh.n3*usgh.n5
!=usgh2.n1*usgh2.n2*usgh2.n3*usgh2.n5)
err(" check gridin=%s \n",datain[i]);
n4 += usgh2.n4;
m5[i] = usgh2.n4;
fseek64(infp[i],0,0);
fprintf(stderr," merge gridin=%s ... o4=%g n4=%d d4=%g \n",
datain[i],usgh2.o4,usgh2.n4,usgh2.d4);
}
for(i5=0;i5<usgh.n5;i5++) {
for(i=0;i<nin;i++) {
nread = m5[i] * usgh.n3 * usgh.n2;
for(i2=0;i2<nread;i2++) {
fread(grid,usgh.dtype,usgh.n1,infp[i]);
fwrite(grid,usgh.dtype,usgh.n1,outfp);
}
}
}
if(headupdate==4) {
usgh.n4 = n4;
} else if(headupdate==5) {
usgh.n5 = n5*nin;
usgh.d5 = usgh.d5/nin;
}
} else if(mergeaxis==3) {
n3 = 0;
for(i=0;i<nin;i++) {
ierr = fgetusghdr(infp[i],&usgh2);
if(ierr!=0) err(" error open gridin=%s \n",datain[i]);
if(usgh.n1*usgh.n2*usgh.n4*usgh.n5
!=usgh2.n1*usgh2.n2*usgh2.n4*usgh2.n5)
err(" check gridin=%s \n",datain[i]);
n3 += usgh2.n3;
m5[i] = usgh2.n3;
fseek64(infp[i],0,0);
fprintf(stderr," merge gridin=%s ... o3=%g n3=%d d3=%g \n",
datain[i],usgh2.o3,usgh2.n3,usgh2.d3);
}
for(i5=0;i5<usgh.n5*usgh.n4;i5++) {
for(i=0;i<nin;i++) {
nread = m5[i] * usgh.n2;
for(i2=0;i2<nread;i2++) {
fread(grid,usgh.dtype,usgh.n1,infp[i]);
fwrite(grid,usgh.dtype,usgh.n1,outfp);
}
}
}
usgh.n3 = n3;
} else if(mergeaxis==2) {
n2 = 0;
for(i=0;i<nin;i++) {
ierr = fgetusghdr(infp[i],&usgh2);
if(ierr!=0) err(" error open gridin=%s \n",datain[i]);
if(usgh.n1*usgh.n3*usgh.n4*usgh.n5
!=usgh2.n1*usgh2.n3*usgh2.n4*usgh2.n5)
err(" check gridin=%s \n",datain[i]);
n2 += usgh2.n2;
m5[i] = usgh2.n2;
fseek64(infp[i],0,0);
fprintf(stderr," merge gridin=%s ... o2=%g n2=%d d2=%g \n",
datain[i],usgh2.o2,usgh2.n2,usgh2.d2);
}
for(i5=0;i5<usgh.n5*usgh.n4*usgh.n3;i5++) {
for(i=0;i<nin;i++) {
nread = m5[i];
for(i2=0;i2<nread;i2++) {
fread(grid,usgh.dtype,usgh.n1,infp[i]);
fwrite(grid,usgh.dtype,usgh.n1,outfp);
}
}
}
usgh.n2 = n2;
} else if(mergeaxis==1) {
for(i=0;i<nin;i++) {
ierr = fgetusghdr(infp[i],&usgh2);
if(ierr!=0) err(" error open gridin=%s \n",datain[i]);
if(usgh.n2*usgh.n3*usgh.n4*usgh.n5
!=usgh2.n2*usgh2.n3*usgh2.n4*usgh2.n5)
err(" check gridin=%s \n",datain[i]);
n1 += usgh2.n1;
m5[i] = usgh2.n1;
fseek64(infp[i],0,0);
fprintf(stderr," merge gridin=%s ... o1=%g n1=%d d1=%g \n",
datain[i],usgh2.o1,usgh2.n1,usgh2.d1);
}
n1out = 0;
for(i2=0;i2<nin;i2++) n1out = n1out + m5[i2];
grido = (char*)malloc(n1out*usgh.dtype);
for(i5=0;i5<usgh.n5*usgh.n4*usgh.n3*usgh.n2;i5++) {
i2 = 0;
for(i=0;i<nin;i++) {
nread = m5[i];
fread(grid,usgh.dtype,nread,infp[i]);
bcopy(grid,grido+i2,nread*usgh.dtype);
i2 = i2 + nread*usgh.dtype;
}
fwrite(grido,usgh.dtype,n1out,outfp);
}
usgh.n1 = n1out;
}
usgh.scale = 1.0;
if(iddupdate==1) {
if(headupdate==1) {
usgh.d1 = ddupdate;
} else if(headupdate==2) {
usgh.d2 = ddupdate;
} else if(headupdate==3) {
usgh.d3 = ddupdate;
} else if(headupdate==4) {
usgh.d4 = ddupdate;
} else if(headupdate==5) {
usgh.d5 = ddupdate;
}
}
ierr = fputusghdr(outfp,&usgh);
if(ierr!=0) err(" error output ");
free(grid);
free(m5);
if(mergeaxis==1) free(grido);
exit (0);
}
/**************** end self doc ********************************/
static void cvstack(VND *vnda, VND *vnd, int icmp, int noff, float *off,
float *mute, int lmute, int nv, float *p2,
float dt, float dtout);
static void vget( float a, float b, float e, float d,
float theta, float *vel);
VND *ptabledmo(int nv, float *v, float etamin, float deta, int neta,
float d, float vsvp, int np, float dp, float dp2, char *file);
VND *ptablemig(int nv, float *v, float etamin, float deta,
int neta, float d, float vsvp, int np, char *file);
static void taper (int lxtaper, int lbtaper,
int nx, int ix, int nt, float *trace);
segy tr; /* input and output SEGY data */
FILE *fpl; /* file pointer for print listing */
int main(int argc, char **argv)
{
VND *vnd=NULL; /* big file holding data, all cmps, all etas, all velocities */
VND *vnda=NULL; /* holds one input cmp gather */
VND *vndb=NULL; /* holds (w,v) for one k component */
VND *vndvnmo=NULL; /* holds (vnmo,p) table for ti dmo */
VND *vndvphase=NULL; /* holds (vphase,p) table for ti Stolt migration */
long N[2]; /* holds number of values in each dimension for VND opens */
long key[2]; /* holds key in each dimension for VND i/o */
char **dir=NULL; /* could hold list of directories where to put VND temp files */
char *file; /* root name for temporary files */
char *printfile; /* name of file for printout */
complex *crt;
complex *ctemp;
complex czero;
float *rt;
char *ccrt;
char *fname;
float etamin; /* minimum eta scan to compute */
float etamax; /* maximum eta scan to compute */
float deta; /* increment in eta to compute for eta scan */
float dx; /* cmp spatial sampling interval */
float dk; /* wavenumber increment */
float dv; /* velocity increment */
float vmin; /* minimum output velocity */
float vmax; /* maximum output velocity */
float dt; /* input sample rate in seconds */
float dtout; /* output sample rate in seconds */
float *mute; /* array of mute times for this cmp */
float *off; /* array of offsets for this cmp */
float *v; /* array of output velocities */
float *p2stack; /* array of stacking 1/(v*v) */
float *rindex; /* array of interpolation indices */
float dp2=0.0; /* increment in slowness squared for input cvstacks */
float scale; /* used for trace scale factor */
float p; /* horizontal slowness */
float p2; /* p*p */
float v2; /* velocity squared */
float ak; /* horizontal wavenumber */
float dw; /* angular frequency increment */
float *w; /* array holding w values for Fowler */
float factor; /* scale factor */
float d; /* Thomsen's delta */
float vsvp; /* vs/vp ratio */
float dp; /* increment of slowness values in vndvnmo table */
float rp; /* real valued index in p */
float wgt; /* weight for linear interpolation */
float fmax; /* maximum frequency to use for antialias mute */
float salias; /* fraction of frequencies to be within sloth antialias limit */
float dpm; /* slowness increment in TI migration table */
float fw; /* first w in Stolt data table */
float vminstack;/* only used if reading precomputed cvstacks, minimum stacking vel */
int neta; /* number of eta scans to compute */
int ichoose; /* defines type of processing to do */
int ncmps; /* number of input and output cmps */
int nv; /* number of output velocity panels to generate */
int nvstack; /* number of cvstack panels to generate */
int ntpad; /* number of time samples to padd to avoid wraparound */
int nxpad; /* number of traces to padd to avoid wraparound */
int lmute; /* number of samples to taper mute */
int lbtaper; /* length of bottom time taper in ms */
int lstaper; /* length of side taper in traces */
int mxfold; /* maximum allowed number of input offsets/cmp */
int icmp; /* cmp index */
int ntfft; /* length of temporal fft for Fowler */
int ntffts; /* length of temporal fft for Stolt */
int nxfft; /* length of spatial fft */
int ntfftny; /* count of freq to nyquist */
int nxfftny; /* count of wavenumbers to nyquist */
int nmax; /* used to compute max number of samples for array allocation */
int oldcmp; /* current cdp header value */
int noff; /* number of offsets */
int k; /* wavenumber index */
int iwmin; /* minimum freq index */
int TI; /* 0 for isotropic, 1 for transversely isotropic */
long it; /* time index */
long iw; /* index for angular frequency */
long nt; /* number of input time samples */
long ntout; /* number of output time samples */
long iv; /* velocity index */
long ip; /* slowness index */
long ieta;
int nonhyp; /* flag equals 1 if do mute to avoid non-hyperbolic events */
int getcvstacks;/* flag equals 1 if input cvstacks precomputed */
int ngroup; /* number of traces per vel anal group */
int ndir; /* number of user specified directories for temp files */
/******************************************************************************/
/* input parameters, allocate buffers, and define reusable constants */
/******************************************************************************/
initargs(argc, argv);
requestdoc(1);
/* get first trace and extract critical info from header */
if(!gettr(&tr)) err("Can't get first trace \n");
nt=tr.ns;
dt=0.000001*tr.dt;
oldcmp=tr.cdp;
if (!getparstring("printfile",&printfile)) printfile=NULL;
if (printfile==NULL) {
fpl=stderr;
}else{
fpl=fopen(printfile,"w");
}
if (!getparfloat("salias",&salias)) salias=0.8;
if(salias>1.0) salias=1.0;
if (!getparfloat("dtout",&dtout)) dtout=1.5*dt;
ntout=1+nt*dt/dtout;
if (!getparint("getcvstacks",&getcvstacks)) getcvstacks=0;
if(getcvstacks) {
dtout=dt;
ntout=nt;
}
fmax=salias*0.5/dtout;
fprintf(fpl,"sutifowler: ntin=%ld dtin=%f\n",nt,dt);
fprintf(fpl,"sutifowler: ntout=%ld dtout=%f\n",ntout,dtout);
if (!getparstring("file",&file)) file="sutifowler";
if (!getparfloat("dx",&dx)) dx=25.;
if (!getparfloat("vmin",&vmin)) vmin=1500.;
if (!getparfloat("vmax",&vmax)) vmax=8000.;
if (!getparfloat("vminstack",&vminstack)) vminstack=vmin;
if (!getparfloat("d",&d)) d=0.0;
if (!getparfloat("etamin",&etamin)) etamin=0.0;
if (!getparfloat("etamax",&etamax)) etamax=0.5;
if (!getparfloat("vsvp",&vsvp)) vsvp=0.5;
if (!getparint("neta", &neta)) neta = 1;
if (fabs(etamax-etamin)<1.0e-7) neta = 1;
if (neta < 1) neta = 1;
if (!getparint("choose", &ichoose)) ichoose = 1;
if (!getparint("ncdps", &ncmps)) err("sutifowler: must enter ncdps");
if (!getparint("nv", &nv)) nv = 75;
if (!getparint("nvstack", &nvstack)) nvstack = 180;
if (!getparint("ntpad", &ntpad)) ntpad = 0.1*ntout;
if (!getparint("nxpad", &nxpad)) nxpad = 0;
if (!getparint("lmute", &lmute)) lmute = 24;
lmute=1 + 0.001*lmute/dtout;
if (!getparint("lbtaper", &lbtaper)) lbtaper = 0;
if (!getparint("lstaper", &lstaper)) lstaper = 0;
if (!getparint("mxfold", &mxfold)) mxfold = 120;
if (!getparint("nonhyp",&nonhyp)) nonhyp=1.;
if (!getparint("ngroup", &ngroup)) ngroup = 20;
ndir = countparname("p");
if(ndir==0) {
ndir=-1;
}else{
dir = (char **)VNDemalloc(ndir*sizeof(char *),"dir");
for(k=0;k<ndir;k++) {
it=getnparstring(k+1,"p",&dir[k]);
}
}
lbtaper=lbtaper/(1000.*dt);
TI=0;
if(fabs(d)>0. || fabs(etamin)>0 || neta>1 ) TI=1;
if(TI) fprintf(fpl,"sutifowler: operation in TI mode\n");
deta = 0.;
if(neta>1) deta=(etamax-etamin)/(neta-1);
dp=1./(vmin*(NP-5));
if(TI) dp=dp*sqrt(1.+2.*fabs(etamin));
if(ichoose>2) nvstack=nv;
if(ichoose==1 || ichoose==2 || ichoose==3) {
ntfft=ntout+ntpad;
}else{
ntfft=1;
}
if(ichoose==1 || ichoose==3) {
ntffts=2*ntout/0.6;
}else{
ntffts=1;
}
ntfft=npfao(ntfft,2*ntfft);
ntffts=npfao(ntffts,2*ntffts);
dw=2.*PI/(ntfft*dtout);
nxfft=npfar(ncmps+nxpad);
dk=2.*PI/(nxfft*dx);
fprintf(fpl,"sutifowler: ntfft=%d ntffts=%d nxfft=%d\n",ntfft,ntffts,nxfft);
czero.r=czero.i=0.;
scale=1.;
if(ichoose<5) scale=1./(nxfft);
if(ichoose==1 || ichoose==2 ) scale*=1./ntfft;
if(ichoose==1 || ichoose==3 ) scale*=1./ntffts;
nxfftny = nxfft/2 + 1;
ntfftny = ntfft/2 + 1;
nmax = nxfftny;
if(ntfft > nmax) nmax=ntfft;
if((NP/2+1)>nmax) nmax=(NP/2+1);
if(nvstack>nmax) nmax=nvstack;
if(nv*neta>nmax) nmax=nv*neta;
ctemp = (complex *)VNDemalloc(nmax*sizeof(complex),"allocating ctemp");
rindex=(float *)VNDemalloc(nmax*sizeof(float),"allocating rindex");
if(ntffts > nmax) nmax=ntffts;
crt = (complex *)VNDemalloc(nmax*sizeof(complex),"allocating crt");
rt = (float *)crt;
ccrt = (char *)crt;
fprintf(fpl,"sutifowler: nv=%d nvstack=%d\n",nv,nvstack);
v=(float *)VNDemalloc(nv*sizeof(float),"allocating v");
p2stack=(float *)VNDemalloc(nvstack*sizeof(float),"allocating p2stack");
mute=(float *)VNDemalloc(mxfold*sizeof(float),"allocating mute");
off=(float *)VNDemalloc(mxfold*sizeof(float),"allocating off");
fprintf(fpl,"sutifowler: allocating and filling w array\n");
w=(float *)VNDemalloc(ntfft*sizeof(float),"allocating w");
for(iw=0;iw<ntfft;iw++) {
if(iw<ntfftny){
w[iw]=iw*dw;
}else{
w[iw]=(iw-ntfft)*dw;
}
if(iw==0) w[0]=0.1*dw; /* fudge for dc component */
}
/******************************************************************************/
fprintf(fpl,"sutifowler: building function for stacking velocity analysis\n");
/******************************************************************************/
dv=(vmax-vmin)/MAX((nv-1),1);
for(iv=0;iv<nv;iv++) v[iv]=vmin+iv*dv;
if(ichoose>=3){
for(iv=0;iv<nvstack;iv++) {
p2stack[iv]=1./(v[iv]*v[iv]);
fprintf(fpl," stacking velocity %ld %f\n",iv,v[iv]);
}
}else{
if(nvstack<6) err("sutifowler: nvstack must be 6 or more");
dp2 = 1./(vminstack*vminstack*(nvstack-5));
for(iv=0;iv<nvstack;iv++) {
p2stack[iv]=iv*dp2;
if(iv>0) {
factor=1./sqrt(p2stack[iv]);
fprintf(fpl," stacking velocity %ld %f\n",iv,factor);
}else{
fprintf(fpl," stacking velocity %ld infinity\n",iv);
}
}
}
/******************************************************************************/
fprintf(fpl,"sutifowler: Opening and zeroing large block matrix disk file\n");
fprintf(fpl," This can take a while, but all is fruitless if the \n");
fprintf(fpl," necessary disk space is not there...\n");
/******************************************************************************/
N[0]=nxfft+2;
N[1]=ntout*MAX(nv*neta,nvstack);
fname=VNDtempname(file);
vnd = VNDop(2,0,2,N,1,sizeof(float),fname,ndir,dir,1);
VNDfree(fname,"main: freeing fname 1");
fprintf(fpl,"sutifowler: large file RAM mem buf = %ld bytes\n",
vnd->NumBytesMemBuf);
fprintf(fpl,"sutifowler: large file disk area = %ld bytes\n",
vnd->NumBytesPerBlock*vnd->NumBlocksPerPanel*vnd->NumPanels);
if(getcvstacks) {
/******************************************************************************/
fprintf(fpl,"sutifowler: reading input cvstacks\n");
/******************************************************************************/
for(icmp=0;icmp<ncmps;icmp++) {
key[0]=icmp;
key[1]=0;
for(iv=0;iv<nvstack;iv++) {
VNDrw('w',0,vnd,1,key,0,
(char *) tr.data,iv*ntout,1,ntout,
1,"writing cvstacks to disk");
if( !gettr(&tr) ) {
if(icmp==ncmps-1 && iv==nvstack-1 ) {
/* all ok, read all the input data */
}else{
err("sutifowler: error reading input cvstacks");
}
}
}
}
goto xffts;
}
/******************************************************************************/
fprintf(fpl,
"sutifowler: beginning constant velocity stacks of the input cmp gathers\n");
/******************************************************************************/
fname=VNDtempname(file);
vnda = V2Dop(2,1000000,sizeof(float),fname,nt,mxfold);
VNDfree(fname,"main: freeing fname 2");
fprintf(fpl,"sutifowler: cmp gather RAM mem buf = %ld bytes\n",
vnda->NumBytesMemBuf);
icmp=0;
noff=0;
do {
if(tr.cdp!=oldcmp) {
cvstack(vnda,vnd,icmp,noff,off,mute,lmute,
nvstack,p2stack,dt,dtout);
icmp++;
if(icmp==ncmps) {
fprintf(fpl,"sutifowler: more input cdps than ncdps parameter\n");
fprintf(fpl," Will only process ncdps gathers.\n");
goto done_with_input;
}
oldcmp=tr.cdp;
noff=0;
}
if(lbtaper>0 || lstaper>0) taper (lstaper,lbtaper,ncmps,icmp,nt,tr.data);
factor=scale;
for(it=0;it<nt;it++) tr.data[it]*=factor;
V2Dw0(vnda,noff,(char *)tr.data,1);
off[noff]=tr.offset;
if(ichoose==1 || ichoose==2) {
mute[noff]=fmax*off[noff]*off[noff]*dp2;
}else{
mute[noff]=0.;
}
if(nonhyp) mute[noff]=MAX(mute[noff],2*off[noff]/vmin);
noff++;
if(noff>mxfold) err("tifowler: input cdp has more traces than mxfold");
} while ( gettr(&tr) );
cvstack(vnda,vnd,icmp,noff,off,mute,lmute,
nvstack,p2stack,dt,dtout);
icmp++;
done_with_input:
ncmps=icmp;
fprintf(fpl,"sutifowler: read and stacked %d cmp gathers\n",ncmps);
VNDcl(vnda,1);
xffts:
VNDflush(vnd);
if(ichoose<5){
/******************************************************************************/
fprintf(fpl,"sutifowler: doing forward x -> k spatial fft's\n");
/******************************************************************************/
for(it=0;it<(ntout*nvstack);it++) {
V2Dr0(vnd,it,ccrt,21);
for(k=ncmps;k<nxfft+2;k++) rt[k]=0.;
pfarc(1,nxfft,rt,crt);
V2Dw0(vnd,it,ccrt,22);
}
VNDr2c(vnd);
}
if(ichoose<=3) {
fprintf(fpl,"sutifowler: looping over k\n");
if(TI && (ichoose==1 || ichoose==2)) { /* build ti vnmo(p) table */
vndvnmo=ptabledmo(nv,v,etamin,deta,neta,d,vsvp,NP,dp,dp2,file);
fprintf(fpl,"sutifowler: dmo index(p) RAM mem buf = %ld bytes\n",
vndvnmo->NumBytesMemBuf);
}
if(TI && (ichoose==1 || ichoose==3)){ /* build ti vphase(p) table */
vndvphase=ptablemig(nv,v,etamin,deta,neta,d,vsvp,NP,file);
fprintf(fpl,"sutifowler: migration scaler(p) RAM mem buf = %ld bytes\n",
vndvphase->NumBytesMemBuf);
}
if(ichoose==1 || ichoose==2){
iv=MAX(nv*neta,nvstack);
fname=VNDtempname(file);
vndb = V2Dop(2,750000,sizeof(complex),
fname,(long)ntfft,iv);
fprintf(fpl,"sutifowler: (w,v) RAM mem buf = %ld bytes\n",
vndb->NumBytesMemBuf);
VNDfree(fname,"main: freeing fname 3");
}
/******************************************************************************/
for(k=0;k<nxfftny;k++){ /* loop over spatial wavenumbers */
/******************************************************************************/
if(k==(20*(k/20))) {
fprintf(fpl,"sutifowler: k index = %d out of %d\n",
k,nxfftny);
}
ak=k*dk;
key[0]=k;
key[1]=0;
/******************************************************************************/
if(ichoose==1 || ichoose==2) { /* do Fowler DMO */
/******************************************************************************/
for(iv=0;iv<nvstack;iv++) { /* loop over input velocities */
VNDrw('r',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
31,"Fowler DMO t -> w fft read");
for(it=ntout;it<ntfft;it++) crt[it]=czero;
pfacc(-1,ntfft,crt);
V2Dw0(vndb,iv,ccrt,32);
}
for(iw=0;iw<ntfft;iw++) {
p=0.5*ak/fabs(w[iw]);
if(TI) { /* anisotropic TI*/
ip=p/dp;
if(ip<NP) {
V2Dr0(vndvnmo,ip,(char *)rindex,40);
}else{
for(iv=0;iv<(nv*neta);iv++) rindex[iv]=-1.;
}
}else{ /* isotropic */
p2=p*p;
for(iv=0;iv<nv;iv++){
v2=v[iv]*v[iv];
rindex[iv]=(1-v2*p2)/(v2*dp2);
}
}
V2Dr1(vndb,iw,ccrt,41);
for(iv=0;iv<nvstack;iv++) ctemp[iv]=crt[iv];
ints8c(nvstack,1.0,0.0,ctemp,czero,czero,nv*neta,rindex,crt);
V2Dw1(vndb,iw,ccrt,42);
}
for(iv=0;iv<(nv*neta);iv++) { /* loop over output vel */
V2Dr0(vndb,iv,ccrt,51);
pfacc(1,ntfft,crt);
VNDrw('w',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
52,"Fowler DMO w -> t fft write");
}
}
/******************************************************************************/
if( ichoose==3 && neta>1 ) { /* fix up disk order if only doing TI migrations */
/******************************************************************************/
for(iv=0;iv<nv;iv++) {
VNDrw('r',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
57,"option 3 fixup for multiple eta read");
for(ieta=1;ieta<neta;ieta++) {
VNDrw('w',0,vnd,1,key,0,ccrt,
iv*ntout+ieta*nv*ntout,1,ntout,
58,"option 3 fixup for multiple eta write");
}
}
}
/******************************************************************************/
if( (ichoose==1 || ichoose==3 ) ) { /* do Stolt migration */
/******************************************************************************/
for(iv=0;iv<(nv*neta);iv++) {
if(TI) { /* anisotropic TI */
V2Dr0(vndvphase,iv,ccrt,50);
dpm=rt[0];
dw=2.*PI/(ntfft*dtout);
iwmin=0.5*ak/( (NP-3)*dpm*dw);
for(iw=iwmin+1;iw<ntfftny;iw++) {
p=0.5*ak/fabs(w[iw]);
rp=1.0+p/dpm;
ip=rp;
wgt=rp-ip;
factor=wgt*rt[ip+1]+(1.-wgt)*rt[ip];
rindex[iw]=w[iw]*factor;
rindex[ntfft-iw]=w[ntfft-iw]*factor;
}
fw=-2.*PI/dtout;
rindex[0]=fw;
for(iw=1;iw<iwmin+1;iw++) {
rindex[iw]=fw;
rindex[ntfft-iw]=fw;
}
}else{ /* isotropic */
scale=0.5*v[iv]*ak;
for(iw=0;iw<ntfft;iw++) {
if(fabs(w[iw])>scale) {
factor=scale/w[iw];
factor=sqrt(1+factor*factor);
rindex[iw]=w[iw]*factor;
}else{
rindex[iw]=-2.*PI/dtout;
}
}
}
VNDrw('r',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
61,"Stolt t -> w fft read");
for(it=1;it<ntout;it+=2){
crt[it].r=-crt[it].r;
crt[it].i=-crt[it].i;
}
for(it=ntout;it<ntffts;it++) crt[it]=czero;
pfacc(1,ntffts,crt);
dw=2.*PI/(ntffts*dtout);
fw=-PI/dtout;
ints8c(ntffts,dw,fw,crt,czero,czero,
ntfft,rindex,ctemp);
/* obliquity factor code */
for(iw=0;iw<ntfft;iw++){
factor=fabs(w[iw]/rindex[iw]);
crt[iw].r=factor*ctemp[iw].r;
crt[iw].i=factor*ctemp[iw].i;
}
pfacc(-1,ntfft,crt);
VNDrw('w',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
62,"Stolt w->t fft write");
}
}
}
fprintf(fpl,"sutifowler: completed loop over wavenumbers\n");
if(ichoose==1 || ichoose==2) VNDcl(vndb,1);
if(TI && (ichoose==1 || ichoose==2)) VNDcl(vndvnmo,1);
if(TI && (ichoose==1 || ichoose==3)) VNDcl(vndvphase,1);
}
if(ichoose<5) {
/******************************************************************************/
fprintf(fpl,"sutifowler: doing inverse spatial fft's k->x\n");
/******************************************************************************/
for(it=0;it<(ntout*nv*neta);it++) {
V2Dr0(vnd,it,ccrt,71);
pfacr(-1,nxfft,crt,rt);
V2Dw0(vnd,it,ccrt,72);
}
VNDc2r(vnd);
}
/*****************************************************************/
fprintf(fpl,"sutifowler: outputting results\n");
/******************************************************************/
it=0;
for(icmp=0;icmp<ncmps;icmp++) {
key[0]=icmp;
key[1]=0;
for(ieta=0;ieta<neta;ieta++) {
for(iv=0;iv<nv;iv++) {
VNDrw('r',0,vnd,1,key,0,(char *)tr.data,
iv*ntout+ieta*nv*ntout,1,ntout,82,
"outputting all velocities for each cmp");
tr.ns=ntout;
tr.dt=1000000*dtout;
tr.cdp=icmp;
tr.tracf=iv;
tr.offset=v[iv];
tr.cdpt=iv;
tr.sx=icmp*dx;
tr.gx=icmp*dx;
it++;
tr.tracl=it;
tr.tracr=it;
tr.fldr=icmp/ngroup;
tr.ep=10+tr.fldr*ngroup;
tr.igc=ieta;
tr.igi=100*(etamin+ieta*deta);
tr.d1=dtout;
tr.f1=0.;
tr.d2=1.;
tr.f2=0.;
puttr(&tr);
}
}
}
/* close files and return */
VNDcl(vnd,1);
VNDfree(crt,"main: freeing crt");
VNDfree(ctemp,"main: freeing ctemp");
VNDfree(v,"main: freeing v");
VNDfree(p2stack,"main: freeing p2stack");
VNDfree(mute,"main: freeing mute");
VNDfree(off,"main: freeing off");
VNDfree(rindex,"main: freeing rindex");
VNDfree(w,"main: freeing w");
if(VNDtotalmem()!=0) {
fprintf(stderr,"total VND memory at end = %ld\n",
VNDtotalmem());
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
FILE *fpint, *fpcp, *fpcs, *fpro;
int example, verbose, writeint, nb;
int above, diffrwidth, dtype;
int Ngp, Ngs, Ngr, Np, Ns, Nr, Ng, Ni, Nv, Nvi, No, Noi;
int jint, jcount, j, ix, iz, nx, nz, nxp, nzp, *zp, nmaxx, nminx, optgrad, poly, gradt;
int ncp, nro, ncs, nvel, skip, rayfile, store_int;
long lseed;
size_t nwrite;
float *data_out, orig[2], cp0, cs0, ro0;
float *x, *z, *var, *interface, **inter;
float back[3], sizex, sizez, dx, dz;
float **cp ,**cs, **ro, aver, gradlen, gradcp, gradcs, gradro;
/* Gradient unit flag */
/* ------------------ */
/* - 0 Unit : m/s per dz */
/* - 1 Unit : m/s per m */
int gradunit;
/* Number of Z-reference points (one per layer) */
int Nzr=0;
float **gridcp, **gridcs, **gridro;
segy *hdrs;
FILE *fpout;
char *file, intt[10], *file_base, filename[150];
initargs(argc, argv);
requestdoc(1);
if (!getparint("example", &example)) example=0;
else { plotexample(); exit(0); }
if(getparstring("file",&file_base))
vwarn("parameters file is changed to file_base");
else {
if(!getparstring("file_base",&file_base))
verr("file_base not specified.");
}
if(getparfloat("back", back)) {
vwarn("parameters back is not used anymore");
vwarn("it has changed into cp0 (ro0,cs0 are optional)");
nb = countparval("back");
if (nb == 1) {
vwarn("The new call should be cp0=%.1f",back[0]);
cp0 = back[0];
}
if (nb == 2) {
vwarn("The new call should be cp0=%.1f",back[0]);
vwarn(" ro0=%.1f",back[1]);
cp0 = back[0];
ro0 = back[1];
}
if (nb == 3) {
vwarn("The new call should be cp0=%.1f",back[0]);
vwarn(" cs0=%.1f",back[1]);
vwarn(" ro0=%.1f",back[2]);
cp0 = back[0];
cs0 = back[1];
ro0 = back[2];
}
vmess("Don't worry everything still works fine");
}
else {
if(!getparfloat("cp0", &cp0)) verr("cp0 not specified.");
if(!getparfloat("cs0", &cs0)) cs0 = -1;
if(!getparfloat("ro0", &ro0)) ro0 = -1;
}
if(!getparfloat("sizex", &sizex)) verr("x-model size not specified.");
if(!getparfloat("sizez", &sizez)) verr("z-model size not specified.");
if(!getparfloat("dx", &dx)) verr("grid distance dx not specified.");
if(!getparfloat("dz", &dz)) verr("grid distance dz not specified.");
if(!getparfloat("orig", orig)) orig[0] = orig[1] = 0.0;
if(!getparint("gradt", &gradt)) gradt = 1;
if(!getparint("gradunit", &gradunit)) gradunit = 0;
if(!getparint("writeint", &writeint)) writeint = 0;
if(!getparint("rayfile", &rayfile)) rayfile = 0;
if(!getparint("skip", &skip)) skip = 5;
if(!getparint("above", &above)) above=0;
if(!getparint("verbose", &verbose)) verbose=0;
if(!getparint("dtype", &dtype)) dtype = 0;
if ((writeint == 1) || (rayfile == 1)) store_int = 1;
else store_int = 0;
/*=================== check parameters =================*/
Np = countparname("cp");
Ns = countparname("cs");
Nr = countparname("ro");
Ng = countparname("grad");
No = countparname("poly");
Ni = countparname("intt");
Nv = countparname("var");
Ngp = countparname("gradcp");
Ngs = countparname("gradcs");
Ngr = countparname("gradro");
Nvi = 0;
for (jint = 1; jint <= Ni; jint++) {
getnparstring(jint,"intt", &file);
strcpy(intt, file);
if (strstr(intt,"sin") != NULL) Nvi++;
if (strstr(intt,"rough") != NULL) Nvi++;
if (strstr(intt,"fract") != NULL) Nvi++;
if (strstr(intt,"elipse") != NULL) Nvi++;
if (strstr(intt,"random") != NULL) Nvi++;
// if (strstr(intt,"randdf") != NULL) Nvi++;
if (strstr(intt,"diffr") != NULL || strstr(intt,"randdf") != NULL) {
Nvi++;
// if (Ng != 0) Ng++;
// if (No != 0) No++;
}
}
// fprintf(stderr,"Nvi=%d ng=%d No=%d np=%d,", Nvi,Ng,No,Np);
if (Np != Nr && ro0 > 0) verr("number of cp and ro not equal.");
if (Np != Ni) verr("number of cp and interfaces not equal.");
if (Nvi != Nv) verr("number of interface variables(var) not correct.");
if (Ns == 0 && Nr == 0) if (verbose>=2) vmess("Velocity model.");
if (Ns == 0) { if (verbose>=2) vmess("Acoustic model."); }
else {
if (verbose>=2) vmess("Elastic model.");
if (Np != Ns) verr("number of cp and cs not equal");
}
if (Ng == 0) {
if (verbose>=2) vmess("No boundary gradients are defined.");
}
else if (Ng != Np) {
verr("number of boundary gradients and interfaces are not equal.");
}
if (Ngp == 0) {
if (verbose>=2) vmess("No interface gradients for cp defined.");
}
else if (Ngp != Np) {
verr("gradcp gradients and interfaces are not equal.");
}
if (Ngs == 0) {
if (verbose>=2) vmess("No interface gradients for cs defined.");
}
else if (Ngs != Np) {
verr("gradcs gradients and interfaces are not equal.");
}
if (Ngr == 0) {
if (verbose>=2) vmess("No interface gradients for rho defined.");
}
else if (Ngr != Np) {
verr("gradro gradients and interfaces are not equal.");
}
if (No == 0) {
if (verbose>=2) vmess("All interfaces are linear.");
}
// else if (No != Np) {
// verr("number of poly variables and interfaces are not equal.");
// }
if (Np > 0) {
if (countparname("x") != Np)
verr("a x array must be specified for each interface.");
if (countparname("z") != Np)
verr("a z array must be specified for each interface.");
}
else Np = 1;
if (Nzr != Np && Nzr !=0) {
verr("number of zref gradients not equal to number of interfaces");
}
/*=================== initialization of arrays =================*/
nz = NINT(sizez/dz)+1;
nx = NINT(sizex/dx)+1;
zp = (int *)malloc(nx*sizeof(int));
interface = (float *)malloc(nx*sizeof(float));
var = (float *)malloc(8*sizeof(float));
gridcp = alloc2float(nz, nx);
if(gridcp == NULL) verr("memory allocation error gridcp");
if (Ns || (NINT(cs0*1e3) >= 0)) {
gridcs = alloc2float(nz, nx);
if(gridcs == NULL) verr("memory allocation error gridcs");
}
else gridcs = NULL;
if (Nr || (NINT(ro0*1e3) >= 0)) {
gridro = alloc2float(nz, nx);
if(gridro == NULL) verr("memory allocation error gridro");
}
else gridro = NULL;
cp = alloc2float(nx,3);
cs = alloc2float(nx,3);
ro = alloc2float(nx,3);
if (store_int == 1) inter = alloc2float(nx, 2*Np);
if (verbose) {
vmess("Origin top left (x,z) . = %.1f, %.1f", orig[0], orig[1]);
vmess("Base name ............. = %s", file_base);
vmess("Number of interfaces .. = %d", Np);
vmess("length in x ........... = %f (=%d)", sizex, nx);
vmess("length in z ........... = %f (=%d)", sizez, nz);
vmess("delta x ............... = %f", dx);
vmess("delta z ............... = %f", dz);
vmess("cp0 ................... = %f", cp0);
if (Ns) vmess("cs0 ................... = %f", cs0);
if (Nr) vmess("ro0 ................... = %f", ro0);
vmess("write interfaces ...... = %d", writeint);
vmess("store interfaces ...... = %d", store_int);
if (above) vmess("define model above interface");
else vmess("define model below interface");
}
/*========== initializing for homogeneous background =============*/
nminx = 0;
nmaxx = nx;
for (j = nminx; j < nmaxx; j++) {
cp[0][j] = cp0;
cs[0][j] = cs0;
ro[0][j] = ro0;
zp[j] = 0;
cp[1][j] = cp0;
cs[1][j] = cs0;
ro[1][j] = ro0;
}
gradlen = 0.0;
gradcp = gradcs = gradro = 0.0;
optgrad = 3;
if (above == 0) {
Nvi = 1; Noi = 1;
} else {
Nvi = Ngp; Noi = Ngp;
}
grid(gridcp, gridcs, gridro, zp, cp, cs, ro, nminx, nmaxx, optgrad,
gradlen, gradcp, gradcs, gradro, dx, dz, nz);
nxp = nzp = 2;
x = (float *)malloc(nxp*sizeof(float));
z = (float *)malloc(nzp*sizeof(float));
if (Ni == 0) {
if (verbose) vmess("No interfaces are defined, Homogeneous model.");
Np = 0;
}
/*========== filling gridded model with interfaces =============*/
for (jcount = 1; jcount <= Np; jcount++) {
/* for above interface definition reverse */
/* order of interfaces to scan */
if (above == 0) jint=jcount;
else jint=Np+1-jcount;
if (verbose) vmess("***** Interface number %d *****", jint);
getnparstring(jint,"intt", &file);
strcpy(intt, file);
nxp = countnparval(jint,"x");
nzp = countnparval(jint,"z");
if (nxp != nzp) {
vmess("nxp = %d nzp =%d for interface %d",nxp, nzp, jint);
verr("Number of x and z values not equal for interface %d",jint);
}
ncp = countnparval(jint,"cp");
nro = countnparval(jint,"ro");
ncs = countnparval(jint,"cs");
if (ncp == 1) {
if (verbose>=2) vmess("No lateral gradient in P velocity");
}
else if (ncp == 2) {
if (verbose) vmess("lateral P-gradient from begin to end");
}
else if (ncp != nxp) {
vmess("ncp = %d nxp =%d for interface %d",ncp, nxp, jint);
verr("Number of cp's and x not equal for interface %d",jint);
}
if (nro <= 1) {
if (verbose>=2) vmess("No lateral gradient in density");
}
else if (nro == 2) {
if (verbose) vmess("lateral Rho-gradient from begin to end");
}
else if (nro != nxp) {
vmess("nro = %d nxp =%d for interface %d",nro, nxp, jint);
verr("Number of ro's and x not equal for interface %d",jint);
}
if (ncs <= 1) {
if (verbose>=2) vmess("No lateral gradient in S velocity");
}
else if (ncs == 2) {
if (verbose) vmess("lateral S-gradient from begin to end");
}
else if (ncs != nxp) {
vmess("ncs = %d nxp =%d for interface %d",ncs, nxp, jint);
verr("Number of cs's and x not equal for interface %d",jint);
}
nvel = MAX(ncp, MAX(nro, ncs));
free(x);
free(z);
x = (float *)malloc(nxp*sizeof(float));
z = (float *)malloc(nzp*sizeof(float));
memset(interface, 0, nx*sizeof(float));
getnparfloat(jint,"x",x);
getnparfloat(jint,"z",z);
getnparfloat(jint,"cp",cp[2]);
if (Nr == 0) ro[2][0] = 0.0;
else getnparfloat(jint,"ro", ro[2]);
if (Ns == 0) cs[2][0] = 0.0;
else getnparfloat(jint,"cs", cs[2]);
if (Ng == 0) gradlen = 0.0;
else getnparfloat(Noi,"grad", &gradlen);
if (No == 0) poly = 0;
else getnparint(Noi,"poly", &poly);
if (Ngp == 0) gradcp = 0.0;
else getnparfloat(Noi,"gradcp", &gradcp);
if (Ngs == 0) gradcs = 0.0;
else getnparfloat(Noi,"gradcs", &gradcs);
if (Ngr == 0) gradro = 0.0;
else getnparfloat(Noi,"gradro", &gradro);
/* if gradunit is in meters, recalculate gradcp,gradcs and gradro */
if (gradunit > 0) {
gradcs = gradcs * dz;
gradcp = gradcp * dz;
gradro = gradro * dz;
}
if (nvel != 1) {
if (ncp == 1) {
for (j = 1; j < nvel; j++) cp[2][j] = cp[2][0];
}
if (ncs == 1) {
for (j = 1; j < nvel; j++) cs[2][j] = cs[2][0];
}
if (nro == 1) {
for (j = 1; j < nvel; j++) ro[2][j] = ro[2][0];
}
}
if (verbose) {
vmess("Interface type .......... = %s", intt);
vmess("Boundary gradient ....... = %f", gradlen);
vmess("Interface gradient cp ... = %f", gradcp);
if (Ns) vmess("Interface gradient cs ... = %f", gradcs);
if (Nr) vmess("Interface gradient ro ... = %f", gradro);
if (verbose>=2) {
vmess("Polynomal ............... = %d", poly);
vmess("Number of (x,z) points... = %d", nxp);
vmess("P-wave velocities ....... = %d", ncp);
if (Ns) vmess("S-wave velocities ....... = %d", ncs);
if (Nr) vmess("Densities ............... = %d", nro);
}
for (j = 0; j < nxp; j++) {
vmess("x = %6.1f \t z = %6.1f", x[j], z[j]);
if (nvel != 1) {
vmess(" cp = %f", cp[2][j]);
if (Ns) vmess(" cs = %f", cs[2][j]);
if (Nr) vmess(" rho = %f", ro[2][j]);
}
}
if (nvel == 1) {
vmess(" cp = %f", cp[2][0]);
if (Ns) vmess(" cs = %f", cs[2][0]);
if (Nr) vmess(" rho = %f", ro[2][0]);
}
}
for (j = 0; j < nxp; j++) {
x[j] -= orig[0];
z[j] -= orig[1];
}
for (j = 0; j < nxp; j++) {
if(x[j] > sizex) verr("x coordinate bigger than model");
if(z[j] > sizez) verr("z coordinate bigger than model");
}
if (gradlen > 0) optgrad = gradt;
else optgrad = 3;
if (strstr(intt,"random") != NULL) {
Nv = countnparval(Nvi,"var");
if (Nv != 1) verr("Random interface must have 1 variables.");
getnparfloat(Nvi,"var", var);
lseed = (long)var[0];
srand48(lseed);
gradcp=gradcs=gradro=var[0];
optgrad = 4;
if (above == 0) Noi++; else Noi--;
if (above == 0) Nvi++; else Nvi--;
}
if ((strstr(intt,"diffr") == NULL) && (strstr(intt,"randdf") == NULL)) {
interpolation(x, z, nxp, nx, poly, &nminx, &nmaxx, dx,
cp, cs, ro, nvel, interface);
}
if ( (strstr(intt,"def") != NULL) || (strstr(intt,"random") != NULL) ) {
linearint(zp, nminx, nmaxx, dz, interface);
if (above == 0) Noi++; else Noi--;
}
if (strstr(intt,"sin") != NULL) {
Nv = countnparval(Nvi,"var");
if (Nv != 2) verr("Sinus interface must have 2 variables.");
getnparfloat(Nvi,"var", var);
sinusint(zp, nminx, nmaxx, dz, interface, dx, var[0], var[1]);
if (above == 0) Noi++; else Noi--;
if (above == 0) Nvi++; else Nvi--;
}
else if (strstr(intt,"rough") != NULL) {
Nv = countnparval(Nvi,"var");
if (Nv != 3) verr("Rough interface must have 3 variables.");
getnparfloat(Nvi,"var", var);
roughint(zp, nminx, nmaxx, dz, interface, var[0],var[1],var[2]);
if (above == 0) Noi++; else Noi--;
if (above == 0) Nvi++; else Nvi--;
}
else if (strstr(intt,"fract") != NULL) {
Nv = countnparval(Nvi, "var");
if (Nv != 6) verr("Fractal interface must have 6 variables.");
getnparfloat(Nvi,"var", var);
fractint(zp, nminx, nmaxx, dx, dz, interface, var[0], var[1],
var[2], var[3], var[4], var[5]);
if (above == 0) Noi++; else Noi--;
if (above == 0) Nvi++; else Nvi--;
}
else if (strstr(intt,"randdf") != NULL) {
float x0, z0, dsx, dsz;
int i;
Nv = countnparval(Nvi, "var");
if (Nv != 2) verr("randdf interface must have 2 variables: number of points, width.");
getnparfloat(Nvi,"var", var);
if(!getparint("dtype", &dtype)) dtype = -1;
randdf(x, z, nxp, dx, dz, gridcp, gridcs, gridro, cp, cs, ro,
interface, zp, nx, sizex, sizez, var[0], (int)var[1], dtype);
if (above == 0) Noi++; else Noi--;
if (above == 0) Nvi++; else Nvi--;
}
else if (strstr(intt,"elipse") != NULL) {
Nv = countnparval(Nvi, "var");
if (Nv != 2) verr("Elipse interface must have 2 variables.");
getnparfloat(Nvi,"var", var);
elipse(x, z, nxp, dx, dz, gridcp, gridcs, gridro,
cp, cs, ro, interface, zp, nz, nx, var[0], var[1], gradcp, gradcs, gradro);
if (above == 0) Noi++; else Noi--;
if (above == 0) Nvi++; else Nvi--;
}
else if ((strstr(intt,"diffr") != NULL)) {
Nv = countnparval(Nvi, "var");
if (Nv == 2 || Nv == 1) {
getnparfloat(Nvi,"var", var);
diffrwidth=(int)var[0];
if (Nv==1) {
if(!getparint("dtype", &dtype)) dtype = 0;
}
else dtype=(int)var[1];
}
else {
verr("diffr interface must have 1 or 2 variables: width,type.");
}
diffraction(x, z, nxp, dx, dz, gridcp, gridcs, gridro,
cp, cs, ro, interface, zp, nx, diffrwidth, dtype);
if (above == 0) Noi++; else Noi--;
if (above == 0) Nvi++; else Nvi--;
}
else {
if (above == 0) {
grid(gridcp, gridcs, gridro, zp, cp, cs, ro, nminx, nmaxx,
optgrad, gradlen, gradcp, gradcs, gradro, dx, dz, nz);
}
else {
gridabove(gridcp, gridcs, gridro, zp, cp, cs, ro, nminx, nmaxx,
optgrad, gradlen, gradcp, gradcs, gradro, dx, dz, nz);
}
}
if (store_int == 1) {
for(j = 0; j < nminx; j++) inter[jint-1][j] = 0.0;
for(j = nminx; j < nmaxx; j++) inter[jint-1][j] = interface[j];
for(j = nmaxx; j < nx; j++) inter[jint-1][j] = 0.0;
for(j = 0; j < nminx; j++) inter[jint-1+Np][j] = 0.0;
for(j = nminx; j < nmaxx; j++) inter[jint-1+Np][j] = zp[j]*dz;
for(j = nmaxx; j < nx; j++) inter[jint-1+Np][j] = 0.0;
}
} /* end of loop over interfaces */
if (verbose) vmess("Writing data to disk.");
hdrs = (segy *) calloc(nx,sizeof(segy));
for(j = 0; j < nx; j++) {
hdrs[j].f1= orig[1];
hdrs[j].f2= orig[0];
hdrs[j].d1= dz;
hdrs[j].d2= dx;
hdrs[j].ns= nz;
hdrs[j].trwf= nx;
hdrs[j].tracl= j;
hdrs[j].tracf= j;
hdrs[j].gx = (orig[0] + j*dx)*1000;
hdrs[j].scalco = -1000;
hdrs[j].timbas = 25;
hdrs[j].trid = TRID_DEPTH;
}
/* due to bug in SU, int-file has to be opened before other files are closed */
if (writeint == 1) {
strcpy(filename, file_base);
name_ext(filename, "_int");
fpint = fopen(filename,"w");
assert(fpint != NULL);
}
/* write P-velocities in file */
strcpy(filename, file_base);
name_ext(filename, "_cp");
fpcp = fopen(filename,"w");
assert(fpcp != NULL);
data_out = (float *)malloc(nx*nz*sizeof(float));
for(ix = 0; ix < nx; ix++) {
for(iz = 0; iz < nz; iz++) {
data_out[ix*nz+iz] = gridcp[ix][iz];
}
nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpcp);
assert(nwrite == TRCBYTES);
nwrite = fwrite( &data_out[ix*nz], sizeof(float), nz, fpcp);
assert(nwrite == nz);
}
fclose(fpcp);
free2float(gridcp);
/* write S-velocities in file */
if (Ns > 0 || getparfloat("cs0", &cs0)) {
strcpy(filename, file_base);
name_ext(filename, "_cs");
fpcs = fopen(filename,"w");
assert(fpcs != NULL);
for(ix = 0; ix < nx; ix++) {
for(iz = 0; iz < nz; iz++) {
data_out[ix*nz+iz] = gridcs[ix][iz];
}
nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpcs);
assert(nwrite == TRCBYTES);
nwrite = fwrite( &data_out[ix*nz], sizeof(float), nz, fpcs);
assert(nwrite == nz);
}
fclose(fpcs);
free2float(gridcs);
} /* end of writing S-velocity file */
/* write densities in file */
if (Nr > 0 || getparfloat("ro0", &ro0)) {
strcpy(filename, file_base);
name_ext(filename, "_ro");
fpro = fopen(filename,"w");
assert(fpro != NULL);
for(ix = 0; ix < nx; ix++) {
for(iz = 0; iz < nz; iz++) {
data_out[ix*nz+iz] = gridro[ix][iz];
}
nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpro);
assert(nwrite == TRCBYTES);
nwrite = fwrite( &data_out[ix*nz], sizeof(float), nz, fpro);
assert(nwrite == nz);
}
fclose(fpro);
free2float(gridro);
} /* end of writing density file */
/* write depths of the interfaces */
if (writeint == 1) {
free(hdrs);
hdrs = (segy *) calloc(Np,sizeof(segy));
for(j = 0; j < Np; j++) {
hdrs[j].fldr = 1;
hdrs[j].timbas = 25;
hdrs[j].f1= orig[0];
hdrs[j].f2= 0.0;
hdrs[j].d1= dx;
hdrs[j].d2= dz;
hdrs[j].ns= nx;
hdrs[j].trwf= Np;
hdrs[j].tracl= j;
hdrs[j].tracf= j;
hdrs[j].trid= TRID_DEPTH;
}
/* note that due to bug in SU, interface file ha salready been opened */
strcpy(filename, file_base);
name_ext(filename, "_int");
free(data_out);
data_out = (float *)malloc(nx*Np*sizeof(float));
for(jint = 0; jint < Np; jint++) {
for(j = 0; j < nx; j++) {
data_out[jint*nx+j] = inter[jint][j]+orig[1];
}
nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpint);
assert(nwrite == TRCBYTES);
nwrite = fwrite( &data_out[jint*nx], sizeof(float), nx, fpint);
assert(nwrite == nx);
}
for(j = 0; j < Np; j++) hdrs[j].fldr = 2;
for(jint = 0; jint < Np; jint++) {
for(j = 0; j < nx; j++) {
data_out[jint*nx+j] = inter[jint+Np][j]+orig[1];
}
nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpint);
assert(nwrite == TRCBYTES);
nwrite = fwrite( &data_out[jint*nx], sizeof(float), nx, fpint);
assert(nwrite == nx);
}
fclose(fpint);
} /* end of writing interface file */
if (rayfile == 1) {
strcpy(filename, file_base);
strcpy(strrchr(filename, '.'), ".mod");
fpout = fopen(filename, "w+");
fprintf(fpout,"RAYTRACE MODEL FILE\n");
fprintf(fpout,"# ASCII file for ray-tracer\n\n");
fprintf(fpout,"# Top interface\n\n");
fprintf(fpout,"x=0,%.1f\n", sizex);
fprintf(fpout,"z=0.,0.\n");
/* for(i = 1; i <= Np; i++) {
fprintf(fpout,"\n# %d th interface\n\nx=",i);
nxp = countnparval(i,"x");
nzp = countnparval(i,"z");
free(x);
free(z);
x = (float *)malloc(nxp*sizeof(float));
z = (float *)malloc(nzp*sizeof(float));
getnparfloat(i,"x",x);
getnparfloat(i,"z",z);
for(j = 0; j < (nxp-1); j ++) fprintf(fpout,"%.1f,", x[j]);
fprintf(fpout,"%.1f\nz=", x[nxp-1]);
for(j = 0; j < (nxp-1); j ++) fprintf(fpout,"%.1f,", z[j]);
fprintf(fpout,"%.1f\n", z[nxp-1]);
}
*/
for(jint = 0; jint < Np; jint++) {
fprintf(fpout,"\n# %d th interface\n\nx=0",jint+1);
for(j = skip; j < nx; j += skip)
fprintf(fpout,",%.1f", (float)j*dx);
fprintf(fpout,"\nz=%.1f", inter[jint][0]);
for(j = skip; j < nx; j += skip)
fprintf(fpout,",%.1f", inter[jint][j]);
fprintf(fpout,"\n");
}
fprintf(fpout,"\n# %d th interface\n\nx=0",jint+1);
for(j = skip; j < nx; j += skip)
fprintf(fpout,",%.1f", (float)j*dx);
fprintf(fpout,"\nz=%.1f", sizez);
for(j = skip; j < nx; j += skip)
fprintf(fpout,",%.1f", sizez);
fprintf(fpout,"\n");
/**/
fprintf(fpout,"\n\n");
fprintf(fpout,"cp=%.1f,", back[0]);
for(jint = 1; jint <= Np; jint++) {
aver = 0.0;
ncp = countnparval(jint,"cp");
getnparfloat(jint,"cp",cp[2]);
for(j = 0; j < ncp; j++)
aver += cp[2][j];
aver = aver/((float)ncp);
if (jint == Np ) fprintf(fpout,"%.1f", aver);
else fprintf(fpout,"%.1f,", aver);
}
fclose(fpout);
free2float(inter);
}
free(hdrs);
return 0;
}
int main (int argc, char **argv)
{
char **text,**font,*textcolor,*boxcolor;
float size,labelCD=0.0,labelCA,labelCW=0.0,labelCH,bigx,bigy,eps,eps2;
float *x;
int n,j,nsub;
size_t nchar;
/* Hook up getpars */
initargs(argc,argv);
requestdoc(0);
/* Get parameters */
if(!getparint("nsub",&nsub))nsub=0;
if(!getparfloat("size",&size))size=30;
if(!getparstring("tcolor",&textcolor))textcolor="black";
if(!getparstring("bcolor",&boxcolor))boxcolor="white";
checkpars();
eps=0.25*size;
eps2=0.1*size;
n=countparname("t");
if(n==0)
err("must enter at least one PSTEXT text stream as parameter t");
if(n!=countparname("f"))
warn("suggest specify same number of values for t and f");
text =(char **)malloc( (n+1)*sizeof(char *) );
font =(char **)malloc( (n+1)*sizeof(char *) );
x = (float *)malloc( (n+1)*sizeof(float) );
for(bigx=eps,bigy=0.,j=0;j<n;j++){
x[j]=bigx;
if(!getnparstring(j+1,"t",&text[j]))text[j]="hello";
if(!getnparstring(j+1,"f",&font[j]))font[j]="Times-Bold";
labelCH = fontheight(font[j],size);
labelCW = fontwidth(font[j],size);
labelCA = fontascender(font[j],size);
labelCD = MIN(labelCD,fontdescender(font[j],size));
nchar = strlen(text[j]);
bigx+=0.5*(((double) nchar)*labelCW);
bigy=MAX(bigy,labelCH+eps+0.0*labelCA);
}
bigx+=eps;
bigx-=0.5*nsub*labelCW;
/* open output eps file */
boundingbox(-eps2,-eps2,bigx+eps2,bigy+eps2);
begineps();
gsave();
rectclip(0.,0.,bigx,bigy);
/* fill background box with background color */
newpath();
moveto(0.,0.);
lineto(bigx,0.);
lineto(bigx,bigy);
lineto(0.,bigy);
closepath();
setcolor(boxcolor);
fill();
/* write out text strings */
setcolor(textcolor);
moveto(eps,eps-labelCD);
for(j=0;j<n;j++) {
setfont(font[j],size);
show(text[j]);
}
/* close output stream */
grestore();
showpage();
endeps();
return EXIT_SUCCESS;
}