int main(int argc, char **argv)
{
int i;
char *srcfile;
char *datfile;
float b,e,k,a;
int nv; float *v;
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get parameters */
if (!getparstring("src", &srcfile)) err("must specify src= source file");
if (!getparstring("dat", &datfile)) err("must specify dat= data file");
if (!getparfloat("b", &b)) b=-INFINITY;
if (!getparfloat("e", &e)) e=INFINITY;
if (!getparfloat("k", &k)) k=0.01;
if (!getparfloat("a", &a)) a=0;
if ((nv=countparval("v"))) {
v=malloc(nv*sizeof(float));
getparfloat("v",v);
}
/* Print out parameters */
printf("src=%s dat=%s b=%f e=%f k=%f a=%f v=",srcfile,datfile,b,e,k,a);
for (i=0;i<nv;i++) printf("%f,",v[i]);
printf("\n");
return 0;
}
int
main(int argc, char **argv)
{
cwp_String key1, key2; /* x and y key header words */
Value val1, val2; /* ... their values */
cwp_String type1, type2;/* ... their types */
int index1, index2; /* ... their indices in hdr.h */
float x, y; /* temps to hold current x & y */
cwp_String outpar; /* name of par file */
register int npairs; /* number of pairs found */
/* Hook up getpars */
initargs(argc, argv);
requestdoc(1);
/* Prevent byte codes from spilling to screen */
if (isatty(STDOUT)) err("must redirect or pipe binary output");
/* Get parameters */
if (!getparstring("key1", &key1)) key1 = "sx";
if (!getparstring("key2", &key2)) key2 = "gx";
type1 = hdtype(key1);
type2 = hdtype(key2);
index1 = getindex(key1);
index2 = getindex(key2);
/* Loop over traces */
npairs = 0;
while(gettr(&tr)) {
gethval(&tr, index1, &val1);
gethval(&tr, index2, &val2);
x = vtof(type1, val1);
y = vtof(type2, val2);
efwrite(&x, FSIZE, 1, stdout);
efwrite(&y, FSIZE, 1, stdout);
++npairs;
}
/* Make parfile if needed */
if (getparstring("outpar", &outpar))
fprintf(efopen(outpar, "w"),
"n=%d label1=%s label2=%s\n",
npairs, key1, key2);
return(CWP_Exit());
}
int
main(int argc, char **argv)
{
/* Segy data constans */
int ntr=0; /* number of traces */
char *outpar=NULL; /* name of file holding output */
FILE *outparfp=stdout; /* ... its file pointer */
initargs(argc, argv);
requestdoc(1);
/* Get information from the first header */
if (!gettr(&tr)) err("can't get first trace");
if (!getparstring("outpar", &outpar)) outpar = "/dev/stdout" ;
outparfp = efopen(outpar, "w");
checkpars();
/* Loop over traces getting a count */
do {
++ntr;
} while(gettr(&tr));
fprintf(outparfp, "%d", ntr);
return(CWP_Exit());
}
main(int argc, char **argv)
{
String key; /* header key word from segy.h */
String type; /* ... its type */
int index; /* ... its index in hdr.h */
Value val; /* ... its value */
void absval(String type, Value *valp);
/* Initialize */
initargs(argc, argv);
askdoc(1);
/* Get key parameter */
if (!getparstring("key", &key)) key = KEY;
file2g(stdin);
file2g(stdout);
type = hdtype(key);
index = getindex(key);
while (gettr(&tr)) {
gethval(&tr, index, &val);
absval(type, &val);
puthval(&tr, index, &val);
puttr(&tr);
}
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
float fz[BUFSIZ];
int iz=0,jz,nz=0;
unsigned int z[BUFSIZ];
char line[BUFSIZ],*lp, *outpar;
FILE *infp=stdin,*outfp=stdout, *outparfp;
unsigned int *uz = &(z[0]);
/* Hook up getpar */
initargs(argc, argv);
requestdoc(1);
/* Prevent floats from dumping on screen */
switch(filestat(STDOUT)) {
case BADFILETYPE:
warn("stdout is illegal filetype");
pagedoc();
break;
case TTY:
warn("stdout can't be tty");
pagedoc();
break;
default: /* rest are OK */
break;
}
/* Get parameters and do set up */
if (!getparstring("outpar", &outpar)) outpar = "/dev/tty" ;
outparfp = efopen(outpar, "w");
while (fgets(line,BUFSIZ,infp)!=NULL) {
/* set pointer to beginning of line */
lp = line;
/* read hex digits from input line */
for(iz=0;sscanf(lp,"%2x",&uz[iz])==1;iz++,nz++,lp+=2);
/* convert to floats */
for(jz=0;jz<iz;jz++)
fz[jz] = 255-z[jz];
/* write floats */
fwrite(fz,sizeof(float),iz,outfp);
}
/* Make par file */
fprintf(outparfp, "total number of values=%d\n",nz);
return(CWP_Exit());
}
main(int argc, char **argv)
{
String output;
bool asciiout = true;
/* Initialize */
initargs(argc, argv);
askdoc(1);
file2g(stdin);
/* Argument count check */
if (argc == 1) err("must specify key(s) as command line arguments");
/* Set and check output disposition (ascii or binary) */
if (!getparstring("output", &output)) output = "ascii";
if ((!STREQ(output, "ascii")) && (!STREQ(output, "binary")))
err("output parameter=%s, must be ascii or binary", output);
if (STREQ(output, "binary")) asciiout = false;
/* Loop over traces writing selected header field values */
while (gettr(&tr)) {
register int i;
for (i = 1; i < argc; ++i) {
String key = argv[i];
Value val;
/* discard command line parameter strings */
if (STREQ(key, "output=ascii") ||
STREQ(key, "output=binary"))
continue;
gethdval(&tr, key, &val);
if (asciiout) { /* ascii output */
printf("%6s=", key);
printfval(hdtype(key), val);
putchar('\t');
} else { /* binary output */
float fval = vtof(hdtype(key), val);
efwrite((char *) &fval, FSIZE, 1, stdout);
}
}
if (asciiout) printf("\n\n");
}
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
double sx, sy, gx, gy, factor;
float mx, my;
short unit;
int degree;
cwp_String outpar;
register int npairs;
/* Initialize */
initargs(argc, argv);
requestdoc(1);
if (!getparint("degree", °ree)) degree=0;
npairs = 0;
while (gettr(&tr)) {
sx = tr.sx;
sy = tr.sy;
gx = tr.gx;
gy = tr.gy;
unit = tr.counit;
/* If tr.scalco not set, use 1 as the value */
factor = (!tr.scalco) ? 1 : tr.scalco;
/* factor < 0 means divide; factor > 0 means to multiply */
if (factor < 0) factor = -1/factor;
/* if necessary, convert from seconds to degrees */
if (unit == 2 && degree == 1) factor /= 3600;
mx = (float) (0.5*(sx + gx) * factor);
my = (float) (0.5*(sy + gy) * factor);
efwrite(&mx, FSIZE, 1, stdout);
efwrite(&my, FSIZE, 1, stdout);
++npairs;
}
/* Make parfile if needed */
if (getparstring("outpar", &outpar))
fprintf(efopen(outpar, "w"), "n=%d\n", npairs);
return(CWP_Exit());
}
int
main(int argc, char **argv)
{
char *outpar; /* name of file holding output parfile */
FILE *outparfp; /* ... its file pointer */
int n1; /* number of floats per line */
size_t n1read; /* number of items read */
size_t n2 = 0; /* number of lines in input file */
float *z; /* binary floats */
/* Hook up getpar */
initargs(argc, argv);
requestdoc(1);
/* Get parameters and do set up */
if (!getparstring("outpar", &outpar)) outpar = "/dev/tty" ;
outparfp = efopen(outpar, "w");
MUSTGETPARINT("n1",&n1);
z = ealloc1float(n1);
/* Loop over data converting to ascii */
while ((n1read = efread(z, FSIZE, n1, stdin))) {
register int i1;
if (n1read != n1)
err("out of data in forming line #%d", n2+1);
for (i1 = 0; i1 < n1; ++i1)
/* z2xyz.c:70: warning: format ‘%d’ expects type ‘int’, but argument 2 has type ‘size_t’ */
/* printf("%d %d %11.4e \n",n2,i1,z[i1]); */
#if __WORDSIZE == 64
printf("%lu %d %11.4e \n",n2,i1,z[i1]);
#else
printf("%u %d %11.4e \n",n2,i1,z[i1]);
#endif
++n2;
}
/* Make par file */
/* z2xyz.c:76: warning: format ‘%d’ expects type ‘int’, but argument 3 has type ‘size_t’ */
/* fprintf(outparfp, "n2=%d\n", n2); */
#if __WORDSIZE == 64
fprintf(outparfp, "n2=%lu\n", n2);
#else
fprintf(outparfp, "n2=%u\n", n2);
#endif
return(CWP_Exit());
}
int
main (int argc, char **argv)
{
int n1,n2,i2;
float f1,f2,d1,d2,*x;
char *label2="Trace",label[256];
FILE *infp=stdin,*outfp=stdout;
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(0);
/* get optional parameters */
if (!getparint("n1",&n1)) {
if (efseeko(infp,(off_t) 0,SEEK_END)==-1)
err("input file size is unknown; specify n1!\n");
if ((n1=((int) (eftello(infp)/((off_t) sizeof(float)))))<=0)
err("input file size is unknown; specify n1!\n");
efseeko(infp,(off_t) 0,SEEK_SET);
}
if (!getparfloat("d1",&d1)) d1 = 1.0;
if (!getparfloat("f1",&f1)) f1 = d1;
if (!getparint("n2",&n2)) n2 = -1;
if (!getparfloat("d2",&d2)) d2 = 1.0;
if (!getparfloat("f2",&f2)) f2 = d2;
getparstring("label2",&label2);
/* allocate space */
x = ealloc1float(n1);
/* loop over 2nd dimension */
for (i2=0; i2<n2 || n2<0; i2++) {
/* read input array, watching for end of file */
if (efread(x,sizeof(float),n1,infp)!=n1) break;
/* make plot label */
sprintf(label,"%s %0.4g",label2,f2+i2*d2);
/* plot the array */
prp1d(outfp,label,n1,d1,f1,x);
}
return(CWP_Exit());
}
main(int argc, char **argv)
{
String key;
String type;
int index;
double a, c, b, d, i, j;
int itr = 0;
Value val;
FILE *infp=stdin, *outfp=stdout;
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get parameters */
if (!getparstring("key", &key)) key = "cdp";
if (!getpardouble("a" , &a)) a = 0;
if (!getpardouble("b" , &b)) b = 0;
if (!getpardouble("c" , &c)) c = 0;
if (!getpardouble("d" , &d)) d = 0;
if (!getpardouble("j" , &j)) j = ULONG_MAX;
type = hdtype(key);
index = getindex(key);
file2g(infp);
file2g(outfp);
while (gettr(&tr)) {
i = (double) itr++ + d;
setval(type, &val, a, b, c, i, j);
puthval(&tr, index, &val);
puttr(&tr);
}
return EXIT_SUCCESS;
}
/* the main program */
int main (int argc, char **argv)
{
double vp1,vp2,vs1,vs2,rho1,rho2;
double eps1,eps2,delta1,delta2;
double gamma1,gamma2,azimuth;
float fangle,langle,dangle,angle;
double *coeff,p=0;
double sangle,cangle,sazi,cazi;
float anglef,dummy;
FILE *outparfp=NULL, *coeffp=NULL;
int ibin,modei,modet,rort,iangle,iscale,index;
char *outparfile=NULL,*coeffile=NULL;
Stiff2D *spar1, *spar2;
double **a,*rcond,*z;
int *ipvt;
/* allocate space for stiffness elements */
spar1=(Stiff2D*)emalloc(sizeof(Stiff2D));
spar2=(Stiff2D*)emalloc(sizeof(Stiff2D));
/* allocate space for matrix system */
a = alloc2double(6,6);
coeff = alloc1double(6);
ipvt=alloc1int(6);
z = alloc1double(6);
rcond=alloc1double(6);
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(0);
if (!getparint("ibin",&ibin)) ibin = 1;
if (!getparint("modei",&modei)) modei = 0;
if (!getparint("modet",&modet)) modet = 0;
if (!getparint("rort",&rort)) rort = 1;
if (!getparint("iscale",&iscale)) iscale = 0;
if (!getparint("test",&test)) test = 1;
if (!getparint("info",&info)) info = 0;
if(modei != 0 && modei !=1 && modei !=2){
fprintf(stderr," \n ERROR wrong incidence mode \n");
return (-1); /* wrong mode */
}
if(modet != 0 && modet !=1 && modet !=2){
fprintf(stderr," \n ERROR wrong scattering mode \n");
return (-1); /* wrong mode */
}
if(rort != 0 && rort !=1){
fprintf(stderr," ERROR wrong rort parameter \n");
return (-1); /* wrong mode */
}
if(iscale != 0 && iscale !=1 && iscale !=2 && iscale!=3 ){
fprintf(stderr," ERROR wrong iscale parameter \n");
return (-1); /* wrong mode */
}
if (!getparfloat("fangle",&fangle)) fangle = 0.0;
if (!getparfloat("langle",&langle)) langle = 45.0;
if (!getparfloat("dangle",&dangle)) dangle = 1.0;
if (!getpardouble("azimuth",&azimuth)) azimuth = 0.;
if (!getpardouble("vp1",&vp1)) vp1 = 2.0;
if (!getpardouble("vp2",&vp2)) vp2 = 2.0;
if (!getpardouble("vs1",&vs1)) vs1 = 1.0;
if (!getpardouble("vs2",&vs2)) vs2 = 1.0;
if (!getpardouble("rho1",&rho1)) rho1 = 2.7;
if (!getpardouble("rho2",&rho2)) rho2 = 2.7;
if (!getpardouble("eps1",&eps1)) eps1 = 0.;
if (!getpardouble("eps2",&eps2)) eps2 = 0.;
if (!getpardouble("delta1",&delta1)) delta1 = 0.;
if (!getpardouble("delta2",&delta2)) delta2 = 0.;
if (!getpardouble("gamma1",&gamma1)) gamma1 = 0.;
if (!getpardouble("gamma2",&gamma2)) gamma2 = 0.;
if (getparstring("outparfile",&outparfile)) {
outparfp = efopen(outparfile,"w");
} else {
outparfp = efopen("outpar","w");
}
if (getparstring("coeffile",&coeffile)) {
coeffp = efopen(coeffile,"w");
} else {
coeffp = efopen("coeff.data","w");
}
/****** some debugging information ******************/
if(info){
ddprint(azimuth);
ddprint(vp1); ddprint(vs1); ddprint(rho1);
ddprint(eps1); ddprint(delta1); ddprint(gamma1);
ddprint(vp2); ddprint(vs2); ddprint(rho2);
ddprint(eps2); ddprint(delta2); ddprint(gamma2);
}
/* convert into rad */
azimuth=azimuth*PI /180.;
sazi=sin(azimuth);
cazi=cos(azimuth);
/****** convertion into cij's ************************/
if (!thom2stiffTI(vp1,vs1,eps1,delta1,gamma1,PI/2.,spar1,1) ){
fprintf(stderr," \n ERROR in thom2stiffTI (1) \n");
return (-1);
}
if (!thom2stiffTI(vp2,vs2,eps2,delta2,gamma2,PI/2.,spar2,1) ){
fprintf(stderr,"\n ERROR in thom2stiffTI (2) \n");
return (-1);
}
/***** more debugging output ************************/
if(info){
diprint(modei);
diprint(modet);
diprint(rort);
ddprint(spar1->a1111);
ddprint(spar1->a3333);
ddprint(spar1->a1133);
ddprint(spar1->a1313);
ddprint(spar1->a2323);
ddprint(spar1->a1212);
ddprint(spar2->a1111);
ddprint(spar2->a3333);
ddprint(spar2->a1133);
ddprint(spar2->a1313);
ddprint(spar2->a2323);
ddprint(spar2->a1212);
}
/******** find generated wave type-index ************/
/* reflect_P (0) reflect_S (1) transm_P (2) transm_S (3) */
if(modet == 0 && rort==1)
index = 0;
else if(modet == 1 && rort==1)
index = 1;
else if(modet == 2 && rort==1)
index = 2;
else if(modet == 0 && rort==0)
index = 3;
else if(modet == 1 && rort==0)
index = 4;
else if(modet == 2 && rort==0)
index = 5;
else {
fprintf(stderr,"\n ERROR wrong (index) \n ");
return (-1);
}
/***************** LOOP OVER ANGLES ************************/
for(angle=fangle,iangle=0;angle<=langle;angle+=dangle){
if(info) ddprint(angle);
sangle=(double) angle*PI/180;
cangle=cos(sangle);
sangle=sin(sangle);
/* get horizontal slowness */
if(p_hor3DTIH(spar1,modei,sangle,cangle,sazi,cazi,&p)!=1){
fprintf(stderr,"\n ERROR in p_hor3DTIH \n ");
return (-1);
}
/* compute reflection/transmission coefficient */
if(graebner3D(spar1,spar2,rho1,rho2,modei,modet,rort,
sazi,cazi,p,coeff,a,ipvt,z,rcond)!=1){
fprintf(stderr,"\n ERROR in p_hor3DTIH \n ");
return (-1);
}
++iangle;
if(iscale==0)
anglef=(float) angle;
else if(iscale==1)
anglef=(float) angle*PI/180.;
else if(iscale==2)
anglef=(float) p;
else if(iscale==3)
anglef=(float) sangle*sangle;
dummy= (float)coeff[index];
/* Binary output for x_t */
if(ibin==1){
fwrite(&anglef,sizeof(float),1,coeffp);
fwrite(&dummy,sizeof(float),1,coeffp);
/* ASCII output */
} else if(ibin==0){
fprintf(coeffp,"%f %f\n",anglef,dummy);
}
}
/********* No of output pairs for plotting ********/
if(ibin) fprintf(outparfp,"%i\n",iangle);
return 1;
}
int main (int argc, char **argv)
{
FILE *fp_in, *fp_out;
char *fin, *fout, *ptr, fbegin[100], fend[100], fins[100], fin2[100], numb1[100];
float *indata, *outdata, *rtrace, fz, fx;
float dt, dx, t0, x0, xmin, xmax, sclsxgx, dt2, dx2, t02, x02, xmin2, xmax2, sclsxgx2, dxrcv, dzrcv;
int nshots, nt, nx, ntraces, nshots2, nt2, nx2, ntraces2, ix, it, is, ir, pos, ifile, file_det, nxs, nzs;
int xcount, numb, dnumb, ret, nzmax, verbose;
segy *hdr_in, *hdr_out;
initargs(argc, argv);
requestdoc(1);
if (!getparstring("file_in", &fin)) fin = NULL;
if (!getparstring("file_out", &fout)) fout = "out.su";
if (!getparint("numb", &numb)) numb=0;
if (!getparint("dnumb", &dnumb)) dnumb=0;
if (!getparint("nzmax", &nzmax)) nzmax=0;
if (!getparint("verbose", &verbose)) verbose=0;
if (fin == NULL) verr("Incorrect downgoing input");
if (dnumb < 1) dnumb = 1;
sprintf(numb1,"%d",numb);
ptr = strstr(fin,numb1);
pos = ptr - fin + 1;
sprintf(fbegin,"%*.*s", pos-1, pos-1, fin);
sprintf(fend,"%s", fin+pos);
file_det = 1;
nzs=0;
while (file_det) {
sprintf(fins,"%d",nzs*dnumb+numb);
sprintf(fin,"%s%s%s",fbegin,fins,fend);
fp_in = fopen(fin, "r");
if (fp_in == NULL) {
if (nzs == 0) {
verr("error on opening basefile=%s", fin);
}
else if (nzs == 1) {
vmess("1 file detected");
}
else {
vmess("%d files detected",nzs);
file_det = 0;
break;
}
}
fclose(fp_in);
nzs++;
if (nzmax!=0 && nzs == nzmax) {
vmess("%d files detected",nzs);
file_det = 0;
break;
}
}
sprintf(fins,"%d",numb);
sprintf(fin2,"%s%s%s",fbegin,fins,fend);
nshots = 0;
getFileInfo(fin2, &nt, &nx, &nshots, &dt, &dx, &t0, &x0, &xmin, &xmax, &sclsxgx, &ntraces);
sprintf(fins,"%d",numb+dnumb);
sprintf(fin2,"%s%s%s",fbegin,fins,fend);
nshots = 0;
getFileInfo(fin2, &nt2, &nx2, &nshots2, &dt2, &dx2, &t02, &x02, &xmin2, &xmax2, &sclsxgx2, &ntraces2);
dxrcv=dx*1000;
dzrcv=t02-t0;
if (nshots==0) nshots=1;
nxs = ntraces;
// ngath zijn het aantal schoten
hdr_out = (segy *)calloc(nxs,sizeof(segy));
outdata = (float *)calloc(nxs*nzs,sizeof(float));
hdr_in = (segy *)calloc(nxs,sizeof(segy));
indata = (float *)calloc(nxs,sizeof(float));
readSnapData(fin2, &indata[0], &hdr_in[0], nshots, nxs, nt, 0, nxs, 0, nt);
nshots = hdr_in[nxs-1].fldr;
nxs = hdr_in[nxs-1].tracf;
for (ir = 0; ir < nzs; ir++) {
if (verbose) vmess("Depth:%d out of %d",ir+1,nzs);
sprintf(fins,"%d",ir*dnumb+numb);
sprintf(fin2,"%s%s%s",fbegin,fins,fend);
fp_in = fopen(fin2, "r");
if (fp_in == NULL) {
verr("Error opening file");
}
fclose(fp_in);
readSnapData(fin2, &indata[0], &hdr_in[0], nshots, nxs, nt, 0, nxs, 0, nt);
if (ir==0) fz=hdr_in[0].f1; fx=hdr_in[0].f2;
if (ir==1) dzrcv=hdr_in[0].f1-fz;
for (is = 0; is < nxs; is++) {
for (it = 0; it < nshots; it++) {
outdata[it*nxs*nzs+is*nzs+ir] = indata[it*nxs+is];
}
}
}
free(indata);
fp_out = fopen(fout, "w+");
for (is = 0; is < nshots; is++) {
for (ix = 0; ix < nxs; ix++) {
hdr_out[ix].fldr = is+1;
hdr_out[ix].tracl = is*nxs+ix+1;
hdr_out[ix].tracf = ix+1;
hdr_out[ix].scalco = -1000;
hdr_out[ix].scalel = -1000;
hdr_out[ix].sdepth = hdr_in[0].sdepth;
hdr_out[ix].trid = 1;
hdr_out[ix].ns = nzs;
hdr_out[ix].trwf = nxs;
hdr_out[ix].ntr = hdr_out[ix].fldr*hdr_out[ix].trwf;
hdr_out[ix].f1 = fz;
hdr_out[ix].f2 = fx;
hdr_out[ix].dt = dt*(1E6);
hdr_out[ix].d1 = dzrcv;
hdr_out[ix].d2 = dxrcv;
hdr_out[ix].sx = (int)roundf(fx + (ix*hdr_out[ix].d2));
hdr_out[ix].gx = (int)roundf(fx + (ix*hdr_out[ix].d2));
hdr_out[ix].offset = (hdr_out[ix].gx - hdr_out[ix].sx)/1000.0;
}
ret = writeData(fp_out, &outdata[is*nxs*nzs], hdr_out, nzs, nxs);
if (ret < 0 ) verr("error on writing output file.");
}
fclose(fp_out);
return 0;
}
int main(int argc, char **argv)
{
char *plotcmd; /* build pswigb command for popen */
float *trbuf; /* trace buffer */
FILE *plotfp; /* fp for plot data */
int nt; /* number of samples on trace */
int ntr; /* number of traces */
int verbose; /* verbose flag */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
cwp_Bool seismic; /* is this seismic data? */
cwp_Bool have_ntr=cwp_false;/* is ntr known from header or user? */
char *tmpdir; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false;/* true for user given path */
char *cwproot; /* value of CWPROOT environment variable*/
char *bindir; /* directory path for tmp files */
/* Support for irregularly spaced data */
cwp_String key; /* header key word with x2 information */
cwp_String type1=NULL; /* ... its type */
int index1=0; /* ... its index */
Value val; /* value of key */
Value scale; /* Value of scaler */
cwp_String type2=NULL; /* ... its type */
int index2=0; /* ... its index */
cwp_Bool isDepth=cwp_false; /* Is this key a type of depth? */
cwp_Bool isCoord=cwp_false; /* Is this key a type of coordinate? */
cwp_Bool irregular=cwp_false; /* if true, reading x2 from header */
cwp_String x2string; /* string of x2 values */
off_t x2len; /* ... its length */
cwp_String style; /* style parameter */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
seismic = ISSEISMIC(tr.trid);
nt = tr.ns;
ntr = tr.ntr;
if (ntr) have_ntr = cwp_true;
if (!getparint("verbose", &verbose)) verbose=0;
if (!getparfloat("d1", &d1)) {
if (tr.d1) d1 = tr.d1;
else if (tr.dt) d1 = ((double) tr.dt)/1000000.0;
else {
if (seismic) {
d1 = 0.004;
warn("tr.dt not set, assuming dt=0.004");
} else { /* non-seismic data */
d1 = 1.0;
warn("tr.d1 not set, assuming d1=1.0");
}
}
}
if (!getparfloat("f1", &f1)) {
if (tr.f1) f1 = tr.f1;
else if (tr.delrt) f1 = (float) tr.delrt/1000.0;
else f1 = 0.0;
}
/* Get or set ntr */
if (getparint("n2", &ntr) || getparint("ntr", &ntr)) have_ntr = cwp_true;
if (!getparfloat("d2", &d2)) d2 = (tr.d2) ? tr.d2 : 1.0;
if (!getparfloat("f2", &f2)) {
if (tr.f2) f2 = tr.f2;
else if (tr.tracr) f2 = (float) tr.tracr;
else if (tr.tracl) f2 = (float) tr.tracl;
else if (seismic) f2 = 1.0;
else f2 = 0.0;
}
if (!getparstring("style", &style)) style = "seismic";
if (getparstring("key", &key)) {
type1 = hdtype(key);
if ( (index1 = getindex(key)) == -1 )
err("%s: keyword not in segy.h: '%s'", __FILE__, key);
irregular = cwp_true;
isDepth = IS_DEPTH(key);
isCoord = IS_COORD(key);
if (isDepth) {
index2 = getindex("scalel");
type2 = hdtype("scalel");
} else if (isCoord) {
index2 = getindex("scalco");
type2 = hdtype("scalco");
}
}
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* See if CWPBIN environment variable is not set */
if (!(bindir = getenv("CWPBIN"))) { /* construct bindir from CWPROOT */
bindir = (char *) emalloc(BUFSIZ);
/* Get value of CWPROOT environment variable */
if (!(cwproot = getenv("CWPROOT"))) cwproot ="" ;
if (STREQ(cwproot, "")) {
warn("CWPROOT environment variable is not set! ");
err("Set CWPROOT in shell environment as per instructions in CWP/SU Installation README files");
}
/* then bindir = $CWPROOT/bin */
sprintf(bindir, "%s/bin", cwproot);
}
strcat(bindir,"/"); /* put / at the end of bindir */
/* Allocate trace buffer */
trbuf = ealloc1float(nt);
if (!have_ntr || irregular ) { /* count traces */
if (verbose) {
if (irregular) {
warn("trace spacing from header field %s",key);
warn("... getting positions");
} else {
warn("n2 not getparred and "
"ntr header field not set");
warn(".... counting traces");
}
}
/* Create temporary "file" to hold data */
if (STREQ(tmpdir,"")) {
datafp = etmpfile();
if (irregular) x2fp = etmpfile();
if (verbose) warn("using tmpfile() call");
} else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(datafile, temporary_filename(directory));
strcpy(x2file, temporary_filename(directory));
/* Handle user interrupts */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
datafp = efopen(datafile, "w+");
if (irregular) x2fp = efopen(x2file, "w+");
istmpdir=cwp_true;
if (verbose)
warn("putting temporary files in %s", directory);
}
/* Loop over input data and read to temporary file */
ntr = 0;
if(irregular ) {
float x,xmin=FLT_MAX,xmax=-FLT_MAX;
fprintf(x2fp,"x2=");
do {
if(ntr) fprintf(x2fp,",");
++ntr;
gethval(&tr,index1,&val);
if (isDepth || isCoord) {
gethval(&tr,index2,&scale);
x = (float) (vtod(type1,val) *
pow(10.0,vtod(type2,scale)));
} else
x = vtof(type1,val);
fprintf(x2fp,"%g",x);
xmin = MIN(xmin,x);
xmax = MAX(xmax,x);
if (isDepth && STREQ(style,"vsp")) {
int i;
for (i = 0; i < nt; ++i) tr.data[i] *= -1.0;
}
efwrite(tr.data, FSIZE, nt, datafp);
} while (gettr(&tr));
/* Flip vertical axis if style = vsp */
if (isDepth && STREQ(style,"vsp")) {
fprintf(x2fp," x2beg=%g x2end=%g",xmax,xmin);
style = "normal";
}
if(xmin==xmax) {
warn("values in header %s all equal,",key);
warn("using f2=%f d2=%f",f2,d2);
irregular=cwp_false;
have_ntr=cwp_false;
efclose(x2fp);
if (istmpdir) eremove(x2file);
}
} else {
do {
++ntr;
efwrite(tr.data, FSIZE, nt, datafp);
} while (gettr(&tr));
/* Save naive user */
if (STREQ(style,"vsp")) {
style = "normal";
warn("style=vsp requires key= to be set");
}
}
}
/* Set up pswigb command line */
if (irregular ) {
x2len = (off_t) eftell( x2fp );
x2string = (char *) emalloc( ++x2len );
rewind(x2fp);
fread(x2string,sizeof(char),x2len,x2fp);
plotcmd = (char *) emalloc(x2len+BUFSIZ);
if (STREQ(style,"vsp")) {
style = "normal";
}
sprintf(plotcmd, "%spswigb n1=%d d1=%f f1=%f %s style=%s", bindir,
nt, d1, f1, x2string, style);
free(x2string);
} else {
if (STREQ(style,"vsp")) {
style = "normal";
}
plotcmd = (char *) emalloc(BUFSIZ);
sprintf(plotcmd,
"%spswigb n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f style=%s", bindir,
nt, ntr, d1, d2, f1, f2, style);
}
for (--argc, ++argv; argc; --argc, ++argv) {
if (strncmp(*argv, "d1=", 3) && /* skip those already set */
strncmp(*argv, "d2=", 3) &&
strncmp(*argv, "f1=", 3) &&
strncmp(*argv, "f2=", 3) &&
strncmp(*argv, "style=", 6)){
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe to pswigb and send the traces */
plotfp = epopen(plotcmd, "w");
free(plotcmd);
if (!have_ntr || irregular) { /* send out stored traces one by one */
rewind(datafp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread (trbuf, FSIZE, nt, datafp);
efwrite(trbuf, FSIZE, nt, plotfp);
}
}
} else { /* just pump out traces and let pswigb do the work */
do {
efwrite(tr.data, FSIZE, nt, plotfp);
} while (gettr(&tr));
}
/* Clean up */
epclose(plotfp);
if (!have_ntr) {
efclose(datafp);
if (istmpdir) eremove(datafile);
}
if (irregular) {
efclose(x2fp);
if (istmpdir) eremove(x2file);
}
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
cwp_String key1,key2,key3; /* panel/trace/flag key */
cwp_String type1,type2,type3; /* type for panel/trace/flag key*/
int index1,index2,index3; /* indexes for key1/2/3 */
Value val1,val2,val3; /* value of key1/2/3 */
double dval1=0.0,dval2=0.0,dval3=0.0; /* value of key1/2/3 */
double c; /* trace key spacing */
double dmin,dmax,dx; /* trace key start/end/spacing */
double panelno=0.0,traceno=0.0;
int nt; /* number of samples per trace */
int isgn; /* sort order */
int iflag; /* internal flag: */
/* -1 exit */
/* 0 regular mode */
/* 1 first time */
/* 2 trace out of range */
/* initialize */
initargs(argc, argv);
requestdoc(1);
/* get parameters */
if (!getparstring("key1", &key1)) key1 = "ep";
if (!getparstring("key2", &key2)) key2 = "tracf";
if (!getparstring("key3", &key3)) key3 = "trid";
if (!getpardouble("val3", &dval3)) dval3 = 2.;
if (!getpardouble("d", &dx)) dx = 1.;
if (!getpardouble("min", &dmin)) err("need lower panel boundary MIN");
if (!getpardouble("max", &dmax)) err("need upper panel boundary MAX");
checkpars();
/* check parameters */
if (dx==0) err("trace spacing d cannot be zero");
if (dmax<dmin) err("max needs to be greater than min");
if (dx<0) {
isgn = -1;
} else {
isgn = 1;
}
/* get types and index values */
type1 = hdtype(key1);
type2 = hdtype(key2);
type3 = hdtype(key3);
index1 = getindex(key1);
index2 = getindex(key2);
index3 = getindex(key3);
/* loop over traces */
iflag = 1;
while (iflag>=0) {
if (gettr(&tr)) {
/* get header values */
gethval(&tr, index1, &val1);
gethval(&tr, index2, &val2);
dval1 = vtod(type1, val1);
dval2 = vtod(type2, val2);
/* Initialize zero trace */
nt = tr.ns;
memset( (void *) nulltr.data, 0, nt*FSIZE);
if ( iflag==1 ) {
panelno = dval1;
traceno = dmin - dx;
}
iflag = 0;
if ( dval2<dmin || dval2>dmax ) iflag = 2;
/* fprintf(stderr,"if=%d, dmin=%8.0f, dmax=%8.0f\n",iflag,dmin,dmax);*/
} else {
iflag = -1; /* exit flag */
}
/* fprintf(stderr,"if=%d, dval1=%8.0f, dval2=%8.0f\n",iflag,dval1,dval2);*/
/* if new panel or last trace --> finish the previous panel */
if ( panelno!=dval1 || iflag==-1 ) {
/* fprintf(stderr,"finish previous\n");*/
for (c=traceno+dx; isgn*c<=isgn*dmax; c=c+dx) {
assgnval(type2, &val2, c);
puthval(&nulltr, index2, &val2);
assgnval(type3, &val3, dval3);
puthval(&nulltr, index3, &val3);
puttr(&nulltr);
}
traceno = dmin - dx; /* reset to pad present panel */
panelno = dval1; /* added by Ted Stieglitz 28Nov2012*/
}
/* if trace within boundaries --> pad the present panel */
if ( iflag==0 ) {
/* fprintf(stderr,"pad present, trn=%5.0f,dval2=%5.0f\n",traceno,dval2);*/
memcpy( (void *) &nulltr, (const void *) &tr, 240);
for (c=traceno+dx; isgn*c<isgn*dval2; c=c+dx) {
assgnval(type2, &val2, c);
puthval(&nulltr, index2, &val2);
assgnval(type3, &val3, dval3);
puthval(&nulltr, index3, &val3);
puttr(&nulltr);
}
}
/* write the present trace and save header indices */
if ( iflag==0 ) {
puttr(&tr);
panelno = dval1;
traceno = dval2;
}
}
return(CWP_Exit());
}
int
main(int argc, char **argv)
{
char *key=NULL; /* header key word from segy.h */
char *type=NULL; /* ... its type */
int index; /* ... its index */
Value val; /* ... its value */
float fval; /* ... its value cast to float */
float *xshift=NULL; /* array of key shift curve values */
float *tshift=NULL; /* ... shift curve time values */
int nxshift; /* number of key shift values */
int ntshift; /* ... shift time values */
int nxtshift; /* number of shift values */
int it; /* sample counter */
int itr; /* trace counter */
int nt; /* number of time samples */
int ntr=0; /* number of traces */
int *inshift=NULL; /* array of (integer) time shift values
used for positioning shifted trace in
data[][] */
float dt; /* time sampling interval */
cwp_String xfile=""; /* file containing positions by key */
FILE *xfilep=NULL; /* ... its file pointer */
cwp_String tfile=""; /* file containing times */
FILE *tfilep=NULL; /* ... its file pointer */
int verbose; /* flag for printing information */
char *tmpdir=NULL; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false;/* true for user-given path */
int median; /* flag for median filter */
int nmed; /* no. of traces to median filter */
int nmix; /* number of traces to mix over */
int imix; /* mixing counter */
float *mix=NULL; /* array of mix values */
int sign; /* flag for up/down shift */
int shiftmin=0; /* minimum time shift (in samples) */
int shiftmax=0; /* maximum time shift (in samples) */
int ntdshift; /* nt + shiftmax */
size_t mixbytes; /* size of mixing array */
size_t databytes; /* size of data array */
size_t shiftbytes; /* size of data array */
float *temp=NULL; /* temporary array */
float *dtemp=NULL; /* temporary array */
float *stemp=NULL; /* rwh median sort array */
float **data=NULL; /* mixing array */
int subtract; /* flag for subtracting shifted data */
/* rwh extra pointers for median sort */
int first; /* start pointer in ring buffer */
int middle; /* middle pointer in ring buffer */
int last; /* last pointer in ring buffer */
int halfwidth; /* mid point */
int trcount; /* pointer to current start trace number */
float tmp; /* temp storage for bubble sort */
int rindex; /* wrap around index for ring buffer */
int jmix; /* internal pointer for bubble sort */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get parameters */
if (!(getparstring("xfile",&xfile) && getparstring("tfile",&tfile))) {
if (!(nxshift = countparval("xshift")))
err("must give xshift= vector");
if (!(ntshift = countparval("tshift")))
err("must give tshift= vector");
if (nxshift != ntshift)
err("lengths of xshift, tshift must be the same");
xshift = ealloc1float(nxshift); getparfloat("xshift", xshift);
tshift = ealloc1float(nxshift); getparfloat("tshift", tshift);
} else {
MUSTGETPARINT("nshift",&nxtshift);
nxshift = nxtshift;
xshift = ealloc1float(nxtshift);
tshift = ealloc1float(nxtshift);
if((xfilep=fopen(xfile,"r"))==NULL)
err("cannot open xfile=%s\n",xfile);
if (fread(xshift,sizeof(float),nxtshift,xfilep)!=nxtshift)
err("error reading xfile=%s\n",xfile);
fclose(xfilep);
if((tfilep=fopen(tfile,"r"))==NULL)
err("cannot open tfile=%s\n",tfile);
if (fread(tshift,sizeof(float),nxtshift,tfilep)!=nxtshift)
err("error reading tfile=%s\n",tfile);
fclose(tfilep);
}
if (!getparstring("key", &key)) key = "tracl";
/* Get key type and index */
type = hdtype(key);
index = getindex(key);
/* Get mix weighting values values */
if ((nmix = countparval("mix"))!=0) {
mix = ealloc1float(nmix);
getparfloat("mix",mix);
/* rwh check nmix is odd */
if (nmix%2==0) {
err("number of mixing coefficients must be odd");
}
} else {
nmix = 5;
mix = ealloc1float(nmix);
mix[0] = VAL0;
mix[1] = VAL1;
mix[2] = VAL2;
mix[3] = VAL3;
mix[4] = VAL4;
}
/* Get remaning parameters */
if (!getparint("median",&median)) median = 0;
if (!getparint("nmed",&nmed) && median) nmed = 5;
if (!getparint("sign",&sign)) sign = -1;
if (!getparint("subtract",&subtract)) subtract = 1;
if (!getparint("verbose", &verbose)) verbose = 0;
/* rwh check nmed is odd */
if (median && nmed%2==0) {
nmed=nmed+1;
warn("increased nmed by 1 to ensure it is odd");
}
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* rwh fix for median filter if median true set nmix=nmed */
if (!median) {
/* Divide mixing weights by number of traces to mix */
for (imix = 0; imix < nmix; ++imix)
mix[imix]=mix[imix]/((float) nmix);
} else {
nmix=nmed;
}
/* Get info from first trace */
if (!gettr(&tr)) err("can't read first trace");
if (!tr.dt) err("dt header field must be set");
dt = ((double) tr.dt)/1000000.0;
nt = (int) tr.ns;
databytes = FSIZE*nt;
/* Tempfiles */
if (STREQ(tmpdir,"")) {
tracefp = etmpfile();
headerfp = etmpfile();
if (verbose) warn("using tmpfile() call");
} else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(tracefile, temporary_filename(directory));
strcpy(headerfile, temporary_filename(directory));
/* Trap signals so can remove temp files */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
tracefp = efopen(tracefile, "w+");
headerfp = efopen(headerfile, "w+");
istmpdir=cwp_true;
if (verbose) warn("putting temporary files in %s", directory);
}
/* Read headers and data while getting a count */
do {
++ntr;
efwrite(&tr, 1, HDRBYTES, headerfp);
efwrite(tr.data, 1, databytes, tracefp);
} while (gettr(&tr));
rewind(headerfp);
rewind(tracefp);
/* Allocate space for inshift vector */
inshift = ealloc1int(ntr);
/* Loop over headers */
for (itr=0; itr<ntr; ++itr) {
float tmin=tr.delrt/1000.0;
float t;
/* Read header values */
efread(&tr, 1, HDRBYTES, headerfp);
/* Get value of key and convert to float */
gethval(&tr, index, &val);
fval = vtof(type,val);
/* Linearly interpolate between (xshift,tshift) values */
intlin(nxshift,xshift,tshift,tmin,tshift[nxshift-1],1,&fval,&t);
/* allow for fractional shifts -> requires interpolation */
inshift[itr] = NINT((t - tmin)/dt);
/* Find minimum and maximum shifts */
if (itr==0) {
shiftmax=inshift[0];
shiftmin=inshift[0];
} else {
shiftmax = MAX(inshift[itr],shiftmax);
shiftmin = MIN(inshift[itr],shiftmin);
}
}
rewind(headerfp);
rewind(tracefp);
if (verbose) {
for (itr=0;itr<ntr;itr++)
warn("inshift[%d]=%d",itr,inshift[itr]);
}
/* Compute databytes per trace and bytes in mixing panel */
ntdshift = nt + shiftmax;
shiftbytes = FSIZE*ntdshift;
mixbytes = shiftbytes*nmix;
if (verbose) {
warn("nt=%d shiftmax=%d shiftmin=%d",nt,shiftmax,shiftmin);
warn("ntdshift=%d shiftbytes=%d mixbytes=%d",
ntdshift,shiftbytes,mixbytes);
}
/* Allocate space and zero data array */
data = ealloc2float(ntdshift,nmix);
temp = ealloc1float(ntdshift);
dtemp = ealloc1float(nt);
memset( (void *) data[0], 0, mixbytes);
/* rwh array for out of place bubble sort (so we do not corrupt order in ring buffer */
stemp = ealloc1float(nmix);
/* rwh first preload ring buffer symmetrically (now you know why nmix must be odd) */
trcount=-1;
halfwidth=(nmix-1)/2+1;
first = 0;
last = nmix-1;
middle = (nmix-1)/2;
for (itr=0; itr<halfwidth; itr++) {
efread(tr.data, 1, databytes, tracefp);
trcount++;
for(it=0; it<nt; ++it) {
/* sign to account for positive or negative shift */
/* tr.data needs to be interpolated for non-integer shifts */
data[middle-itr][it + shiftmax + sign*inshift[itr]] = tr.data[it];
data[middle+itr][it + shiftmax + sign*inshift[itr]] = tr.data[it];
}
}
/* Loop over traces performing median filtering */
for (itr=0; itr<ntr; ++itr) {
/* paste header and data on output trace */
efread(&tr, 1, HDRBYTES, headerfp);
/* Zero out temp and dtemp */
memset((void *) temp, 0, shiftbytes);
memset((void *) dtemp, 0, databytes);
/* Loop over time samples */
for (it=0; it<nt; ++it) {
/* Weighted moving average (mix) ? */
if (!median) {
for(imix=0; imix<nmix; ++imix) {
temp[it] += data[imix][it] * mix[imix];
}
} else {
/* inlcude median stack */
/* rwh do bubble sort and choose median value */
for(imix=0; imix<nmix; ++imix) {
stemp[imix]=data[imix][it];
}
for (imix=0; imix<nmix-1; imix++) {
for (jmix=0; jmix<nmix-1-imix; jmix++) {
if (stemp[jmix+1] < stemp[jmix]) {
tmp = stemp[jmix];
stemp[jmix] = stemp[jmix+1];
stemp[jmix+1] = tmp;
}
}
}
temp[it] = stemp[middle];
}
/* shift back mixed data and put into dtemp */
if (subtract) {
if ((it - shiftmax - sign*inshift[itr])>=0)
dtemp[it - shiftmax - sign*inshift[itr]] = data[middle][it]-temp[it];
} else {
if ((it - shiftmax)>=0)
dtemp[it - shiftmax - sign*inshift[itr]] = temp[it];
}
}
memcpy((void *) tr.data,(const void *) dtemp,databytes);
/* Bump rows of data[][] over by 1 to free first row for next tr.data */
for (imix=nmix-1; 0<imix; --imix)
memcpy((void *) data[imix],(const void *) data[imix-1],shiftbytes);
/*for (it=0; it<nt; ++it)
data[imix][it] = data[imix-1][it];*/
/* Write output trace */
tr.ns = nt;
puttr(&tr);
/* read next trace into buffer */
if (trcount < ntr) {
efread(tr.data, 1, databytes, tracefp);
trcount++;
/* read tr.data into first row of mixing array */
/* WMH: changed ntdshift to nt */
for(it=0; it<nt; ++it) {
/* sign to account for positive or negative shift */
/* tr.data needs to be interpolated for non-integer shifts */
data[0][it + shiftmax + sign*inshift[trcount]] = tr.data[it];
}
} else {
rindex=2*(trcount-ntr);
memcpy((void *) data[0],(const void *) data[rindex],shiftbytes);
trcount++;
}
}
if (verbose && subtract) warn("filtered data subtracted from input");
/* Clean up */
efclose(headerfp);
if (istmpdir) eremove(headerfile);
efclose(tracefp);
if (istmpdir) eremove(tracefile);
return(CWP_Exit());
}
int main(int argc, char **argv)
{
int i,ix,it; /* loop counters */
int wtype; /* =1 psv. =2 sh wavefields */
int wfield; /* =1 displcement =2 velocity =3 acceleration */
int stype; /* source type */
int int_type; /* =1 for trapezoidal rule. =2 for Filon */
int flt; /* =1 apply earth flattening correction */
int rand; /* =1 for random velocity layers */
int qopt; /* some flag ???? */
int vsp; /* =1 for vsp, =0 otherwise */
int win; /* =1 if frequency windowing required */
int verbose; /* flag to output processing information */
int nt; /* samples per trace in output traces */
int ntc; /* samples per trace in computed traces */
int nx; /* number of output traces */
int np; /* number of ray parameters */
int nlint=0; /* number of times layer interp is required */
int lsource; /* layer on top of which the source is located*/
int nw; /* number of frequencies */
int nor; /* number of receivers */
int nlayers; /* number of reflecting layers */
int layern;
int nrand_layers; /* maximum number of random layers permitted */
int nf; /* number of frequencies in output traces */
int *filters_phase=NULL; /* =0 for zero phase, =1 for minimum phase fil*/
int nfilters; /* number of required filters */
int wavelet_type; /* =1 spike =2 ricker1 =3 ricker2 =4 akb */
float dt; /* time sampling interval */
float tsec; /* trace length in seconds */
float fpeak; /* peak frequency for output wavelet */
float fref; /* first frequency */
float p2w; /* maximum ray parameter value */
float bp; /* smallest ray parameter (s/km) */
float bx; /* beginning of range in Kms. */
float fx; /* final range in Kms. */
float dx; /* range increment in Kms. */
float pw1,pw2,pw3,pw4; /* window ray parameters (to apply taper) */
float h1; /* horizontal linear part of the source */
float h2; /* vertical linear part of the source */
float m0; /* seismic moment */
float m1,m2,m3; /* components of the moment tensor */
float delta; /* dip */
float lambda; /* rake */
float phis; /* azimuth of the fault plane */
float phi; /* azimuth of the receiver location */
float sdcl,sdct; /* standar deviation for p and s-wave vels */
float z0=0.0; /* reference depth */
float zlayer; /* thickness of random layers */
int layer; /* layer over on top of which to compute rand*/
float tlag; /* time lag in output traces */
float red_vel; /* erducing velocity */
float w1=0.0; /* low end frequency cutoff for taper */
float w2=0.0; /* high end frequency cutoff for taper */
float wrefp; /* reference frequency for p-wave velocities */
float wrefs; /* reference frequency for s-wave velocities */
float epsp; /* .... for p-wave velocities */
float epss; /* .... for p-wave velocities */
float sigp; /* .... for p-wave velocities */
float sigs; /* .... for s-wave velocities */
float fs; /* sampling parameter, usually 0.07<fs<0.12 */
float decay; /* decay factor to avoid wraparound */
int *lobs; /* layers on top of which lay the receivers */
int *nintlayers=NULL; /* array of number of layers to interpolate */
int *filters_type; /* array of 1 lo cut, 2 hi cut, 3 notch */
float *dbpo=NULL; /* array of filter slopes in db/octave */
float *f1=NULL; /* array of lo frequencies for filters */
float *f2=NULL; /* array of high frequencies for filters */
float *cl; /* array of compressional wave velocities */
float *ql; /* array of compressional Q values */
float *ct; /* array of shear wave velocities */
float *qt; /* array of shear Q values */
float *rho; /* array of densities */
float *t; /* array of absolute layer thickness */
int *intlayers=NULL; /* array of layers to interpolate */
float *intlayth=NULL; /* array of thicknesses over which to interp */
float **wavefield1; /* array for pressure wavefield component */
float **wavefield2=NULL;/* array for radial wavefield component */
float **wavefield3=NULL;/* array for vertical wavefield component */
char *lobsfile=""; /* input file receiver layers */
char *clfile=""; /* input file of p-wave velocities */
char *qlfile=""; /* input file of compressional Q-values */
char *ctfile=""; /* input file of s-wave velocities */
char *qtfile=""; /* input file of shear Q-values */
char *rhofile=""; /* input file of density values */
char *tfile=""; /* input file of absolute layer thicknesses */
char *intlayfile=""; /* input file of layers to interpolate */
char *nintlayfile=""; /* input file of number of layers to interp */
char *intlaythfile=""; /*input file of layer thickness where to inter*/
char *filtypefile=""; /* input file of filter types to apply */
char *fphfile=""; /* input file of filters phases */
char *dbpofile=""; /* input file of filter slopes in db/octave */
char *f1file=""; /* input file of lo-end frequency */
char *f2file=""; /* input file of hi-end frequency */
char *wfp=""; /* output file of pressure */
char *wfr=""; /* output file of radial wavefield */
char *wfz=""; /* output file of vertical wavefield */
char *wft=""; /* output file of tangential wavefield */
char *outf=""; /* output file for processing information */
FILE *wfp_file; /* file pointer to output pressure */
FILE *wfr_file; /* file pointer to output radial wavefield */
FILE *wfz_file; /* file pointer to output vertical wavefield */
FILE *wft_file; /* file pointer to output tangential wavefield*/
FILE *outfp=NULL; /* file pointer to processing information */
FILE *infp; /* file pointer to input information */
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(0); /* no input data */
/* get required parameter, seismic moment */
if (!getparfloat("m0",&m0))
err("error: the seismic moment, m0, is a required parameter\n");
/*********************************************************************/
/* get general flags and set their defaults */
if (!getparint("rand",&rand)) rand = 0;
if (!getparint("qopt",&qopt)) qopt = 0;
if (!getparint("stype",&stype)) stype = 1;
if (!getparint("wtype",&wtype)) wtype = 1;
if (!getparint("wfield",&wfield)) wfield = 1;
if (!getparint("int_type",&int_type)) int_type= 1;
if (!getparint("flt",&flt)) flt = 0;
if (!getparint("vsp",&vsp)) vsp = 0;
if (!getparint("win",&win)) win = 0;
if (!getparint("wavelet_type",&wavelet_type)) wavelet_type = 1;
if (!getparint("verbose",&verbose)) verbose = 0;
/* get model parameters and set their defaults */
if (!getparint("lsource",&lsource)) lsource = 0;
if (!getparfloat("fs",&fs)) fs = 0.07;
if (!getparfloat("decay",&decay)) decay = 50.0;
if (!getparfloat("tsec",&tsec)) tsec = 2.048;
/* get response parameters and set their defaults */
if (!getparfloat("fref",&fref)) fref = 1.0;
if (!getparint("nw",&nw)) nw = 100;
if (!getparint("nor",&nor)) nor = 100;
if (!getparint("np",&np)) np = 1300;
if (!getparfloat("p2w",&p2w)) p2w = 5.0;
if (!getparfloat("bx",&bx)) bx = 0.005;
if (!getparfloat("bp",&bp)) bp = 0.0;
if (!getparfloat("fx",&fx)) fx = 0.1;
if (!getparfloat("dx",&dx)) dx = 0.001;
if (!getparfloat("pw1",&pw1)) pw1 = 0.0;
if (!getparfloat("pw2",&pw2)) pw2 = 0.1;
if (!getparfloat("pw3",&pw3)) pw3 = 6.7;
if (!getparfloat("pw4",&pw4)) pw4 = 7.0;
if (!getparfloat("h1",&h1)) h1 = 1.0;
if (!getparfloat("h2",&h2)) h2 = 0.0;
/* get output parameters and set their defaults */
if (!getparint("nx",&nx)) nx = 100;
if (!getparfloat("dt",&dt)) dt = 0.004;
if (!getparint("nt",&nt)) nt = tsec/dt;
if (!getparint("nf",&nf)) nf = 50;
if (!getparfloat("red_vel",&red_vel)) red_vel = 5;
if (!getparfloat("fpeak",&fpeak)) fpeak = 25.;
if (!getparfloat("tlag",&tlag)) tlag = 0.;
/* get names of output files */
if (wtype==1) {
getparstring("wfp",&wfp);
getparstring("wfr",&wfr);
getparstring("wfz",&wfz);
} else if (wtype==2) {
getparstring("wft",&wft);
} else err ("wtype has to be zero or one");
/*********************************************************************/
/* get or compute moment tensor components */
if (stype==1) {
/* get source parameters */
if (!getparfloat("delta",&delta))
err("if stype==1, delta is a required parameter\n");
if (!getparfloat("lambda",&lambda))
err("if stype==1, lambda is a required parameter\n");
if (!getparfloat("phis",&phis))
err("if stype==1, phis is a required parameter\n");
if (!getparfloat("phi",&phi))
err("if stype==1, phi is a required parameter\n");
/* compute moment tensor components */
compute_moment_tensor (wtype, phi, lambda, delta, phis, m0,
&m1, &m2, &m3);
} else if (stype==2) {
/* get moment tensor components from input */
if (!getparfloat("m1",&m1))
err("if stype==2, m1 is a required parameter\n");
if (!getparfloat("m2",&m2))
err("if stype==2, m2 is a required parameter\n");
if (!getparfloat("m3",&m3))
err("if stype==2, m3 is a required parameter\n");
} else err("error, stype flag has to be one or two\n");
/*********************************************************************/
/* if q-option is not requesed, set corresponding parameters to zero */
if (!getparint("layern",&layern)) layern =0;
if (!getparfloat("wrefp",&wrefp)) wrefp =0.0;
if (!getparfloat("wrefs",&wrefs)) wrefs =0.0;
if (!getparfloat("epsp",&epsp)) epsp =0.0;
if (!getparfloat("epss",&epss)) epss =0.0;
if (!getparfloat("sigp",&sigp)) sigp =0.0;
if (!getparfloat("sigs",&sigs)) sigs =0.0;
/*********************************************************************/
/* get number of layers and check input parameters */
if (*clfile=='\0') { /* p-wave vels input from the comand line */
nlayers=countparval("cl");
} else { /* p-wave vels input from a file */
getparint("nlayers",&nlayers);
}
if (*ctfile=='\0') { /* s-wave vels input from the comand line */
if (nlayers !=countparval("cl"))
err("number of p-wave and s-wave velocities"
"has to be the same");
}
if (*qlfile=='\0') { /* compressional q-values from comand line */
if (nlayers !=countparval("ql"))
err("number of p-wave velocities and q-values"
"has to be the same");
}
if (*qtfile=='\0') { /* shear q-values input from comand line */
if (nlayers !=countparval("qt"))
err("number of p-wave velocities and shear q-values"
"has to be the same");
}
if (*rhofile=='\0') { /* densities input from comand line */
if (nlayers !=countparval("rho"))
err("number of p-wave velocities and densities"
"has to be the same");
}
if (*tfile=='\0') { /* layer thicknesses input from comand line */
if (nlayers !=countparval("t"))
err("number of p-wave velocities and thicknesses"
"has to be the same");
}
if (int_type!=1 && int_type!=2) err("int_type flag has to be one or two");
/*********************************************************************/
/* if layer interpolation is requested, get parameters */
if (*intlayfile !='\0') {
getparint("nlint",&nlint);
if ((infp=efopen(intlayfile,"r"))==NULL)
err("cannot open file of layer interp=%s\n",intlayfile);
intlayers=alloc1int(nlint);
fread (intlayers,sizeof(int),nlint,infp);
efclose(infp);
} else if (countparval("intlayers") !=0) {
nlint=countparval("intlayers");
intlayers=alloc1int(nlint);
getparint("intlayers",intlayers);
}
if (*nintlayfile !='\0') {
if ((infp=efopen(nintlayfile,"r"))==NULL)
err("cannot open file of layer inter=%s\n",nintlayfile);
nintlayers=alloc1int(nlint);
fread (nintlayers,sizeof(int),nlint,infp);
efclose(infp);
} else if (countparval("nintlayers") !=0) {
if (nlint !=countparval("nintlayers"))
err("number of values in intlay and nintlay not equal");
nintlayers=alloc1int(nlint);
getparint("nintlayers",nintlayers);
}
if (*intlaythfile !='\0') {
if ((infp=efopen(intlaythfile,"r"))==NULL)
err("cannot open file=%s\n",intlaythfile);
intlayth=alloc1float(nlint);
fread (intlayth,sizeof(int),nlint,infp);
efclose(infp);
} else if (countparval("intlayth") !=0) {
if (nlint !=countparval("intlayth"))
err("# of values in intlay and intlayth not equal");
intlayth=alloc1float(nlint);
getparfloat("intlayth",intlayth);
}
/* update total number of layers */
if (nlint!=0) {
for (i=0; i<nlint; i++) nlayers +=intlayers[i]-1;
}
/*********************************************************************/
/* if random velocity layers requested, get parameters */
if (rand==1) {
getparint("layer",&layer);
getparint("nrand_layers",&nrand_layers);
getparfloat("zlayer",&zlayer);
getparfloat("sdcl",&sdcl);
getparfloat("sdct",&sdct);
} else nrand_layers=0;
/*********************************************************************/
/* allocate space */
cl = alloc1float(nlayers+nrand_layers);
ct = alloc1float(nlayers+nrand_layers);
ql = alloc1float(nlayers+nrand_layers);
qt = alloc1float(nlayers+nrand_layers);
rho = alloc1float(nlayers+nrand_layers);
t = alloc1float(nlayers+nrand_layers);
lobs = alloc1int(nor+1);
lobs[nor]=0;
/*********************************************************************/
/* read input parameters from files or command line */
if (*clfile !='\0') { /* read from a file */
if ((infp=efopen(clfile,"r"))==NULL)
err("cannot open file of pwave velocities=%s\n",clfile);
fread(cl,sizeof(float),nlayers,infp);
efclose(infp);
} else getparfloat("cl",cl); /* get from command line */
if (*qlfile !='\0') {
if ((infp=efopen(qlfile,"r"))==NULL)
err("cannot open file of compressional Q=%s\n",qlfile);
fread(ql,sizeof(float),nlayers,infp);
efclose(infp);
} else getparfloat("ql",ql);
if (*ctfile !='\0') {
if ((infp=efopen(ctfile,"r"))==NULL)
err("cannot open file of swave velocities=%s\n",ctfile);
fread(ct,sizeof(float),nlayers,infp);
efclose(infp);
} else getparfloat("ct",ct);
if (*qtfile !='\0') {
if ((infp=efopen(qtfile,"r"))==NULL)
err("cannot open file of shear Q=%s\n",qtfile);
fread(qt,sizeof(float),nlayers,infp);
efclose(infp);
} else getparfloat("qt",qt);
if (*rhofile !='\0') {
if ((infp=efopen(rhofile,"r"))==NULL)
err("cannot open file of densities=%s\n",rhofile);
fread(rho,sizeof(float),nlayers,infp);
efclose(infp);
} else getparfloat("rho",rho);
if (*tfile !='\0') {
if ((infp=efopen(tfile,"r"))==NULL)
err("cannot open file of thicknesses=%s\n",tfile);
fread(t,sizeof(float),nlayers,infp);
efclose(infp);
} else getparfloat("t",t);
if (*lobsfile !='\0') {
if ((infp=efopen(lobsfile,"r"))==NULL)
err("can't open file of receiver layers=%s\n",lobsfile);
fread(lobs,sizeof(int),nor,infp);
efclose(infp);
} else getparint("lobs",lobs);
/*********************************************************************/
/* if requested, do interpolation and/or parameter adjustment */
if (nlint!=0)
parameter_interpolation (nlayers, intlayers, nintlayers,
intlayth, cl, ql, ct, qt, rho, t);
/* if requested, compute random velocity layers */
if (rand==1) {
random_velocity_layers (&nlayers, &lsource, nrand_layers, sdcl,
sdct, layer, zlayer, cl, ql, ct, qt, rho, t);
}
/* if requested, apply earth flattening approximation */
if (flt==1) {
apply_earth_flattening (nlayers, z0, cl, ct, rho, t);
}
/*********************************************************************/
/* get filter parameters */
if (*filtypefile !='\0') {
if ((infp=efopen(filtypefile,"r"))==NULL)
err("cannot open file=%s\n",filtypefile);
getparint("nfilters",&nfilters);
filters_type=alloc1int(nfilters);
fread (filters_type,sizeof(int),nfilters,infp);
efclose(infp);
} else {
nfilters=countparval("filters_type");
filters_type=alloc1int(nfilters);
getparint("filters_type",filters_type);
}
if (*fphfile !='\0') {
if ((infp=efopen(fphfile,"r"))==NULL)
err("cannot open file=%s\n",fphfile);
filters_phase=alloc1int(nfilters);
fread (filters_phase,sizeof(float),nfilters,infp);
efclose(infp);
} else if (nfilters == countparval("filters_phase")) {
filters_phase=alloc1int(nfilters);
getparint("filters_phase",filters_phase);
} else err("number of elements infilterstype and phase must be equal");
if (*dbpofile !='\0') {
if ((infp=efopen(dbpofile,"r"))==NULL)
err("cannot open file=%s\n",dbpofile);
dbpo=alloc1float(nfilters);
fread (dbpo,sizeof(float),nfilters,infp);
efclose(infp);
} else if (nfilters == countparval("dbpo")) {
dbpo=alloc1float(nfilters);
getparfloat("dbpo",dbpo);
} else err("number of elements in filters_type and dbpo must be equal");
if (*f1file !='\0') {
if ((infp=efopen(f1file,"r"))==NULL)
err("cannot open file=%s\n",f1file);
f1=alloc1float(nfilters);
fread (f1,sizeof(float),nfilters,infp);
efclose(infp);
} else if (nfilters == countparval("f1")) {
f1=alloc1float(nfilters);
getparfloat("f1",f1);
} else err("number of elements in filters_type and f1 must be equal");
if (*f2file !='\0') {
if ((infp=efopen(f2file,"r"))==NULL)
err("cannot open file=%s\n",f2file);
f2=alloc1float(nfilters);
fread (f2,sizeof(float),nfilters,infp);
efclose(infp);
} else if (nfilters == countparval("f2")) {
f2=alloc1float(nfilters);
getparfloat("f2",f2);
} else err("number of elements in filters_type and f2 must be equal");
/*********************************************************************/
/* allocate space for wavefield computations */
wavefield1=alloc2float(nt,nx);
if (wtype==1) {
wavefield2=alloc2float(nt,nx);
wavefield3=alloc2float(nt,nx);
}
/* get name of output file for processing information */
if (verbose==2||verbose==3) {
if (!getparstring("outf",&outf)) outf="info";
if ((outfp=efopen(outf,"w"))==NULL) {
warn("cannot open processing file =%s, no processing\n"
"information file will be generated\n",outf);
verbose=1;
}
}
/* initialize wavefields */
if (wtype==1) {
for (ix=0;ix<nx;ix++) {
for (it=0;it<nt;it++) {
wavefield1[ix][it]=0.0;
wavefield2[ix][it]=0.0;
wavefield3[ix][it]=0.0;
}
}
} else if (wtype==2) {
for (ix=0;ix<nx;ix++) {
for (it=0;it<nt;it++) {
wavefield1[ix][it]=0.0;
}
}
}
/* number of time samples in computed traces */
ntc=tsec/dt;
if (int_type==2) bp=0.0;
/*********************************************************************/
/* Now, compute the actual reflectivities */
compute_reflectivities (int_type, verbose, wtype, wfield, vsp, flt,
win, nx, nt, ntc, nor, nf, nlayers, lsource, layern, nfilters,
filters_phase, nw, np, bp, tlag, red_vel, w1, w2, fx, dx, bx,
fs, decay, p2w, tsec, fref, wrefp, wrefs, epsp, epss, sigp,
sigs, pw1, pw2, pw3, pw4, h1, h2, m1, m2, m3, fref, lobs,
filters_type, dbpo, f1, f2, cl, ct, ql, qt, rho, t, wavefield1,
wavefield2, wavefield3, outfp);
/*********************************************************************/
/* if open, close processing information file */
if (verbose==2||verbose==3) efclose(outfp);
/* convolve with a wavelet and write the results out */
if (wtype==1) { /* PSV */
/* convolve with a wavelet to produce the seismograms */
convolve_wavelet (wavelet_type, nx, nt, dt, fpeak, wavefield1);
convolve_wavelet (wavelet_type, nx, nt, dt, fpeak, wavefield2);
convolve_wavelet (wavelet_type, nx, nt, dt, fpeak, wavefield3);
/* output results in SU format */
if(*wfp!='\0'){
if ((wfp_file=efopen(wfp,"w"))==NULL)
err("cannot open pressure file=%s\n",wfp);
{ register int ix;
for (ix=0; ix<nx; ix++) {
for (it=0; it<nt; it++)
tr1.data[it]=wavefield1[ix][it];
/* headers*/
tr1.ns=nt;
tr1.dt=1000*(int)(1000*dt);
tr1.offset=(bx+ix*dx)*1000;
/* output trace */
fputtr(wfp_file, &tr1);
}
efclose (wfp_file);
}
}
if (*wfr !='\0') {
if ((wfr_file=efopen(wfr,"w"))==NULL)
err("cannot open radial wfield file=%s\n",wfr);
{ register int ix;
for (ix=0; ix<nx; ix++) {
for (it=0; it<nt; it++)
tr2.data[it]=wavefield2[ix][it];
tr2.ns=nt;
tr2.dt=1000*(int)(1000*dt);
tr2.offset=(bx+ix*dx)*1000;
fputtr(wfr_file, &tr2);
}
efclose (wfr_file);
}
}
if (*wfz !='\0') {
if ((wfz_file=efopen(wfz,"w"))==NULL)
err("canno open vertical field file=%s\n",wfz);
{ register int ix;
for (ix=0; ix<nx; ix++) {
for (it=0; it<nt; it++)
tr3.data[it]=wavefield3[ix][it];
tr3.ns=nt;
tr3.dt=1000*(int)(1000*dt);
tr3.offset=(bx+ix*dx)*1000;
fputtr(wfz_file, &tr3);
}
efclose (wfz_file);
}
}
/* free allocated space */
free2float(wavefield1);
free2float(wavefield2);
free2float(wavefield3);
} else if (wtype==2) { /* SH */
/* convolve with a wavelet to produce the seismogram */
convolve_wavelet (wavelet_type, nx, nt, dt, fpeak, wavefield1);
/* output the result in SU format */
if (*wft !='\0') {
if ((wft_file=efopen(wft,"w"))==NULL)
err("cannot open tangential file=%s\n",wft);
{ register int ix;
for (ix=0; ix<nx; ix++) {
for (it=0; it<nt; it++)
tr1.data[it]=wavefield1[ix][it];
tr1.ns=nt;
tr1.dt=1000*(int)(1000*dt);
tr1.offset=(bx+ix*dx)*1000;
fputtr(wft_file, &tr1);
}
efclose (wft_file);
}
}
/* free allocated space */
free2float(wavefield1);
}
/* free workspace */
free1float(cl);
free1float(ct);
free1float(ql);
free1float(qt);
free1float(rho);
free1float(t);
free1int(lobs);
free1int(filters_type);
free1int(filters_phase);
free1float(dbpo);
free1float(f1);
free1float(f2);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
char *tmpdir ; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false ; /* true for user given path */
float *hedr ; /* the headers */
float *data ; /* the data */
int nt ; /* number of trace samples */
float dt ; /* sample interval, sec */
float delrt ; /* delay recording time, sec */
cwp_String key[SU_NKEYS] ; /* array of keywords */
cwp_String type ; /* key string type */
int nkeys ; /* number of keywords */
int ikey,ntr = 0 ; /* counters */
int num ; /* number of traces to dump */
int numtr = 4 ; /* number of traces to dump */
int hpf ; /* header print format */
/* Initialize */
initargs(argc, argv) ;
requestdoc(1) ;
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* Get values from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = (int) tr.ns ; /* Get nt */
dt = ((double) tr.dt)/1000000.0 ; /* microsecs to secs */
if (!dt) getparfloat("dt", &dt) ;
if (!dt) MUSTGETPARFLOAT("dt", &dt) ;
delrt = ((double) tr.delrt)/1000.0 ; /* millisecs to secs */
/* Get parameters */
if (getparint ("num", &num)) numtr = num ;
if ((nkeys=countparval("key"))!=0) getparstringarray("key",key) ;
hedr = ealloc1float(nkeys*numtr) ; /* make space for headers */
if (!getparint ("hpf", &hpf)) hpf = 0 ;
/* Store traces, headers in tempfiles */
if (STREQ(tmpdir,""))
{
tracefp = etmpfile();
headerfp = etmpfile();
do
{
++ntr;
efwrite(&tr, HDRBYTES, 1, headerfp);
efwrite(tr.data, FSIZE, nt, tracefp);
/* Get header values */
for (ikey=0; ikey<nkeys; ++ikey)
{
Value val;
float fval;
gethdval(&tr, key[ikey], &val) ;
type = hdtype(key[ikey]) ;
fval = vtof(type,val) ;
hedr[(ntr-1)*nkeys+ikey] = fval ;
}
}
while (ntr<numtr && gettr(&tr)) ;
}
else /* user-supplied tmpdir */
{
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(tracefile, temporary_filename(directory));
strcpy(headerfile, temporary_filename(directory));
/* Handle user interrupts */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
tracefp = efopen(tracefile, "w+");
headerfp = efopen(headerfile, "w+");
istmpdir=cwp_true;
do
{
++ntr;
efwrite(&tr, HDRBYTES, 1, headerfp);
efwrite(tr.data, FSIZE, nt, tracefp);
/* Get header values */
for (ikey=0; ikey<nkeys; ++ikey)
{
Value val;
float fval;
gethdval(&tr, key[ikey], &val) ;
type = hdtype(key[ikey]) ;
fval = vtof(type,val) ;
hedr[(ntr-1)*nkeys+ikey] = fval ;
}
}
while (ntr<numtr && gettr(&tr)) ;
}
/* Rewind after read, allocate space */
erewind(tracefp);
erewind(headerfp);
data = ealloc1float(nt*ntr);
/* Load traces into data and close tmpfile */
efread(data, FSIZE, nt*ntr, tracefp);
efclose(tracefp);
if (istmpdir) eremove(tracefile);
rewind(headerfp);
rewind(tracefp);
/* Do trace work */
dump(data, dt, hedr, key, delrt, nkeys, ntr, nt, hpf) ;
/* close */
efclose(headerfp);
if (istmpdir) eremove(headerfile);
free1(hedr) ;
free1(data) ;
return(CWP_Exit()) ;
}
main(int argc, char **argv)
{
string head; /* name of file holding headers */
FILE *headfp; /* ... its file pointer */
string outpar; /* name of file holding output parfile */
FILE *outparfp; /* ... its file pointer */
int ns; /* number of data samples on the segys */
int nsbytes; /* ... in bytes */
int ftn; /* fortran flag */
int ntr = 0; /* number of traces written */
FILE *infp=stdin, *outfp=stdout;
/* Initialize */
initargs(argc, argv);
askdoc(1);
switch(filestat(STDOUT)) {
case BADFILETYPE:
warn("stdout is illegal filetype");
selfdoc();
break;
case TTY:
warn("stdout can't be tty");
selfdoc();
break;
}
/* Get parameters */
if (!getparstring("head" , &head)) head = "/dev/null";
if (!getparstring("outpar", &outpar)) outpar = "/dev/tty" ;
if (!getparint ("ftn" , &ftn)) ftn = 0;
if (ftn != 0 && ftn != 1) err("ftn=%d must be 0 or 1", ftn);
/* Open files to save headers and parameters */
headfp = efopen(head, "w");
if( (outparfp = fopen(outpar,"w"))==NULL ) outparfp = stderr;
/*
outparfp = efopen(outpar, "w");
*/
fseek2g(infp,0,1);
fseek2g(outfp,0,1);
/* read id header and save in head */
gethdr(&ch,&bh);
fputhdr(headfp,&ch,&bh);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
ns = tr.ns;
nsbytes = ns * FSIZE;
/* Write the data portion of the records--if the ftn */
/* option is selected, write an int before and after */
/* each trace giving the length of the trace in bytes */
/* as per the Fortran unformatted record format. */
do {
if (ftn) efwrite(&nsbytes, ISIZE, 1, stdout);
efwrite(tr.data, FSIZE, ns, stdout);
if (ftn) efwrite(&nsbytes, ISIZE, 1, stdout);
efwrite(&tr, 1, HDRBYTES, headfp);
++ntr;
} while (gettr(&tr));
/* Make par file for headerless file */
fprintf(outparfp, "n1=%d n2=%d d1=%f\n", tr.ns, ntr,
(float)tr.dt/1000000.0);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
float **data;
char **hdrdata;
float ***workm;
int ival2; /* int value of key2 */
int ival3; /* int value of key3 */
Value val2; /* ... its value */
Value val3; /* ... its value */
int index2;
int index3;
int n1,n2,n3;
int i1,i2,i3;
char *key2=NULL; /* header key word from segy.h */
char *type2=NULL; /* ... its type */
char *key3=NULL; /* header key word from segy.h */
char *type3=NULL; /* ... its type */
int lins;
int line;
int nl;
int dir=2;
int il;
int su;
float cdp;
float t;
float dt;
/* Initialize */
initargs(argc, argv);
requestdoc(1);
MUSTGETPARINT("n2", &n2);
MUSTGETPARINT("n3", &n3);
/* get key2*/
if (!getparstring("key2", &key2)) key2 = "fldr";
type2 = hdtype(key2);
index2 = getindex(key2);
/* get key3*/
if (!getparstring("key3", &key3)) key3 = "tracf";
type3 = hdtype(key3);
index3 = getindex(key3);
if (!getparint("lins", &lins)) lins = 1;
if(lins<1) err(" lins must be larger than 0");
if (!getparint("line", &line)) line = n2;
if (!getparint("su", &su)) su = 1;
/* Get info from first trace */
if (!gettr(&tr)) err ("can't get first trace");
n1 = tr.ns;
if (!getparfloat("dt", &dt)) dt = ((float) tr.dt)/1000000.0;
if (!dt) {
dt = .01;
warn("dt not set, assumed to be .01");
}
data = bmalloc(n1*sizeof(float),n2,n3);
hdrdata = bmalloc(HDRBYTES,n2,n3);
do {
gethval(&tr, index2, &val2);
ival2 = vtoi(type2,val2);
gethval(&tr, index3, &val3);
ival3 = vtoi(type3,val3);
if(ival2>n2 || ival2<0 ) err(" Array in dimension 2 out of bound\n");
if(ival3>n3 || ival3<0 ) err(" Array in dimension 3 out of bound\n");
bmwrite(data,1,ival2-1,ival3-1,1,tr.data);
bmwrite(hdrdata,1,ival2-1,ival3-1,1,&tr);
} while (gettr(&tr));
nl=line-lins+1;
if(dir==2) {
/* n2 direction */
workm = alloc3float(n1,n3,nl);
for(il=lins-1;il<nl;il++) {
for(i3=0;i3<n3;i3++) bmread(data,1,lins+il-1,i3,1,workm[il][i3]);
}
if(su==1) {
fprintf(stdout,"cdp=");
for(il=lins-1;il<nl;il++) {
for(i3=0;i3<n3;i3++) fprintf(stdout,"%d,",(lins+il)*1000+i3+1);
}
for(il=lins-1;il<nl;il++) {
for(i3=0;i3<n3;i3++){
fprintf(stdout,"\ntnmo=");
for(i1=0;i1<n1;i1++) fprintf(stdout,"%.3f,",dt*i1);
fprintf(stdout,"\nvnmo=");
for(i1=0;i1<n1;i1++)
fprintf(stdout,"%.3f,",workm[il][i3][i1]);
}
}
} else {
for(il=lins-1;il<nl;il++) {
for(i3=0;i3<n3;i3++) {
cdp=(lins+il)*1000+i3+1;
fwrite(&cdp,sizeof(float),1,stdout);
}
}
for(il=lins-1;il<nl;il++) {
for(i3=0;i3<n3;i3++){
for(i1=0;i1<n1;i1++) {
t=tr.d1*i1;
fwrite(&t,sizeof(float),1,stdout);
}
for(i1=0;i1<n1;i1++)
fwrite(&workm[il][i3][i1],sizeof(float),1,stdout);
}
}
}
free3float(workm);
}
bmfree(data);
bmfree(hdrdata);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
cwp_String key[SU_NKEYS]; /* array of keywords */
cwp_String type[SU_NKEYS]; /* array of keywords */
int index[SU_NKEYS]; /* name of type of getparred key */
int ikey; /* key counter */
int nkeys; /* number of header fields set */
int count=0; /* number of header fields from file */
double i; /* parameters for computing fields */
int itr = 0; /* trace counter */
Value val; /* value of key field */
char *infile=""; /* name of input file of header values */
FILE *infp=NULL; /* pointer to input file */
cwp_Bool from_file=cwp_false; /* is the data from infile? */
float *afile=NULL; /* array of "a" values from file */
double *a=NULL; /* array of "a" values */
double *b=NULL; /* array of "b" values */
double *c=NULL; /* array of "c" values */
double *d=NULL; /* array of "d" values */
double *j=NULL; /* array of "j" values */
int n; /* number of a,b,c,d,j values */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get "key" values */
if ((nkeys=countparval("key"))!=0) {
getparstringarray("key",key);
} else {
key[0]="cdp";
}
/* get types and indexes corresponding to the keys */
for (ikey=0; ikey<nkeys; ++ikey) {
type[ikey]=hdtype(key[ikey]);
index[ikey]=getindex(key[ikey]);
}
/* get name of infile */
getparstring("infile",&infile);
/* if infile is specified get specified keys from file */
if (*infile!='\0') {
/* open infile */
if((infp=efopen(infile,"r"))==NULL)
err("cannot open infile=%s\n",infile);
/* set from_file flag */
from_file=cwp_true;
}
/* If not from file, getpar a,b,c,d,j */
if (!from_file) {
/* get "a" values */
if ((n=countparval("a"))!=0) {
if (n!=nkeys)
err("number of a values not equal to number of keys");
a=ealloc1double(n);
getpardouble("a",a);
} else {
a=ealloc1double(nkeys);
for (ikey=0; ikey<nkeys; ++ikey) a[ikey]=0.;
}
/* get "b" values */
if ((n=countparval("b"))!=0) {
if (n!=nkeys)
err("number of b values not equal to number of keys");
b=ealloc1double(n);
getpardouble("b",b);
} else {
b=ealloc1double(nkeys);
for (ikey=0; ikey<nkeys; ++ikey) b[ikey]=0.;
}
/* get "c" values */
if ((n=countparval("c"))!=0) {
if (n!=nkeys)
err("number of c values not equal to number of keys");
c=ealloc1double(n);
getpardouble("c",c);
} else {
c=ealloc1double(nkeys);
for (ikey=0; ikey<nkeys; ++ikey) c[ikey]=0.;
}
/* get "d" values */
if ((n=countparval("d"))!=0) {
if (n!=nkeys)
err("number of d values not equal to number of keys");
d=ealloc1double(n);
getpardouble("d",d);
} else {
d=ealloc1double(nkeys);
for (ikey=0; ikey<nkeys; ++ikey) d[ikey]=0.;
}
/* get "j" values */
if ((n=countparval("j"))!=0) {
if (n!=nkeys)
err("number of j values not equal to number of keys");
j=ealloc1double(n);
getpardouble("j",j);
/* make sure that j!=0 */
for (ikey=0; ikey<nkeys; ++ikey)
if(j[ikey]==0) j[ikey]=ULONG_MAX;
} else {
j=ealloc1double(nkeys);
for (ikey=0; ikey<nkeys; ++ikey) j[ikey]=ULONG_MAX;
}
} else { /* if reading from a file */
/* allocate space for afile */
afile=ealloc1float(nkeys);
}
checkpars();
/* loop over traces */
while (gettr(&tr)) {
if (from_file) {
/* use the "a" value from file to trace by trace */
if (efread(afile,FSIZE,nkeys,infp)!=0) {
for (ikey=0; ikey<nkeys; ++ikey) {
double a_in;
a_in=(double) afile[ikey];
setval(type[ikey],&val,a_in,
0,0,0,ULONG_MAX);
puthval(&tr,index[ikey],&val);
++count;
}
}
} else { /* use getparred values of a,b,c,d,j */
for (ikey=0; ikey<nkeys; ++ikey) {
i = (double) itr + d[ikey];
setval(type[ikey],&val,a[ikey],b[ikey],
c[ikey],i,j[ikey]);
puthval(&tr,index[ikey],&val);
}
}
++itr;
puttr(&tr);
}
if (from_file) {
efclose(infp);
if (count < (int)(itr*nkeys) ) {
warn("itr=%d > count=%d %s",(int) itr*count,count);
warn("n traces=%d > data count =%d",(itr*nkeys),count);
}
}
return(CWP_Exit());
}
int main(int argc, char **argv)
{
modPar mod;
recPar rec;
srcPar src;
shotPar shot;
rayPar ray;
float *velocity, *slowness, *smooth, *trueslow, **inter;
double t0, t1, t2, tinit, tray, tio;
size_t size;
int nw, n1, ix, iz, ir, ixshot, izshot;
int nt, ntfft, nfreq, ig;
int irec, sbox, ipos, nrx, nrz, nr;
fcoord coordsx, coordgx, Time;
icoord grid, isrc;
float Jr, *ampl, *time, *ttime, *ttime_p, cp_average, *wavelet, dw, dt;
float dxrcv, dzrcv, rdelay, tr, dt_tmp;
segy hdr;
char filetime[1024], fileamp[1024], *method, *file_rcvtime, *file_src;
size_t nwrite, nread;
int verbose;
complex *cmute, *cwav;
FILE *fpt, *fpa, *fpwav, *fprcv;
t0= wallclock_time();
initargs(argc,argv);
requestdoc(0);
if(!getparint("verbose",&verbose)) verbose=0;
if(!getparint("sbox", &sbox)) sbox = 1;
if(!getparstring("method", &method)) method="jesper";
if (!getparfloat("rec_delay",&rdelay)) rdelay=0.0;
getParameters(&mod, &rec, &src, &shot, &ray, verbose);
/* read file_src if file_rcvtime is defined */
if (!getparstring("file_rcvtime",&file_rcvtime)) file_rcvtime=NULL;
if (file_rcvtime != NULL) {
if (!getparstring("file_src",&file_src)) file_src=NULL;
if (!getparfloat("dt",&dt)) dt=0.004;
if (file_src != NULL ) {
fpwav = fopen( file_src, "r" );
assert( fpwav != NULL);
nread = fread( &hdr, 1, TRCBYTES, fpwav );
assert(nread == TRCBYTES);
ntfft = optncr(MAX(hdr.ns, rec.nt));
wavelet = (float *)calloc(ntfft,sizeof(float));
/* read first trace */
nread = fread(wavelet, sizeof(float), hdr.ns, fpwav);
assert (nread == hdr.ns);
fclose(fpwav);
}
else {
ntfft = optncr(rec.nt);
wavelet = (float *)calloc(ntfft,sizeof(float));
wavelet[0] = 1.0;
}
nfreq = ntfft/2+1;
cwav = (complex *)calloc(nfreq,sizeof(complex));
cmute = (complex *)calloc(nfreq,sizeof(complex));
rc1fft(wavelet,cwav,ntfft,-1);
dw = 2*M_PI/(ntfft*dt);
}
/* allocate arrays for model parameters: the different schemes use different arrays */
n1 = mod.nz;
if(!strcmp(method,"fd")) nw = 0;
else nw = ray.smoothwindow;
velocity = (float *)calloc(mod.nx*mod.nz,sizeof(float));
slowness = (float *)calloc((mod.nx+2*nw)*(mod.nz+2*nw),sizeof(float));
trueslow = (float *)calloc(mod.nx*mod.nz,sizeof(float));
if(!strcmp(method,"fd")) {
ttime = (float *)calloc(mod.nx*mod.nz,sizeof(float));
}
/* read velocity and density files */
readModel(mod, velocity, slowness, nw);
/* allocate arrays for wavefield and receiver arrays */
size = shot.n*rec.n;
time = (float *)calloc(size,sizeof(float));
ampl = (float *)calloc(size,sizeof(float));
/* Sinking source and receiver arrays:
If P-velocity==0 the source and receiver
postions are placed deeper until the P-velocity changes.
Setting the option rec.sinkvel only sinks the receiver position
(not the source) and uses the velocity
of the first receiver to sink through to the next layer. */
/* sink receivers to value different than sinkvel */
for (ir=0; ir<rec.n; ir++) {
iz = rec.z[ir];
ix = rec.x[ir];
while(velocity[(ix)*n1+iz] == rec.sinkvel) iz++;
rec.z[ir]=iz+rec.sinkdepth;
rec.zr[ir]=rec.zr[ir]+(rec.z[ir]-iz)*mod.dz;
// rec.zr[ir]=rec.z[ir]*mod.dz;
if (verbose>3) vmess("receiver position %d at grid[ix=%d, iz=%d] = (x=%f z=%f)", ir, ix, rec.z[ir], rec.xr[ir]+mod.x0, rec.zr[ir]+mod.z0);
}
vmess(" - method for ray-tracing = %s", method);
/*
*/
/* sink sources to value different than zero */
for (izshot=0; izshot<shot.nz; izshot++) {
for (ixshot=0; ixshot<shot.nx; ixshot++) {
iz = shot.z[izshot];
ix = shot.x[ixshot];
while(velocity[(ix)*n1+iz] == 0.0) iz++;
shot.z[izshot]=iz+src.sinkdepth;
}
}
if (verbose>3) writeSrcRecPos(&mod, &rec, &src, &shot);
/* smooth slowness grid */
grid.x = mod.nx;
grid.z = mod.nz;
grid.y = 1;
if ( nw != 0 ) { /* smooth slowness */
smooth = (float *)calloc(grid.x*grid.z,sizeof(float));
applyMovingAverageFilter(slowness, grid, nw, 2, smooth);
memcpy(slowness,smooth,grid.x*grid.z*sizeof(float));
free(smooth);
}
/* prepare output file and headers */
strcpy(filetime, rec.file_rcv);
name_ext(filetime, "_time");
fpt = fopen(filetime, "w");
assert(fpt != NULL);
if (ray.geomspread) {
strcpy(fileamp, rec.file_rcv);
name_ext(fileamp, "_amp");
fpa = fopen(fileamp, "w");
assert(fpa != NULL);
}
if (file_rcvtime != NULL) {
fprcv = fopen(file_rcvtime, "w");
assert(fprcv != NULL);
}
memset(&hdr,0,sizeof(hdr));
hdr.scalco = -1000;
hdr.scalel = -1000;
hdr.trid = 0;
t1=wallclock_time();
tinit = t1-t0;
tray=0.0;
tio=0.0;
/* Outer loop over number of shots */
for (izshot=0; izshot<shot.nz; izshot++) {
for (ixshot=0; ixshot<shot.nx; ixshot++) {
t2=wallclock_time();
if (verbose) {
vmess("Modeling source %d at gridpoints ix=%d iz=%d", (izshot*shot.n)+ixshot, shot.x[ixshot], shot.z[izshot]);
vmess(" which are actual positions x=%.2f z=%.2f", mod.x0+mod.dx*shot.x[ixshot], mod.z0+mod.dz*shot.z[izshot]);
vmess("Receivers at gridpoint x-range ix=%d - %d", rec.x[0], rec.x[rec.n-1]);
vmess(" which are actual positions x=%.2f - %.2f", mod.x0+rec.xr[0], mod.x0+rec.xr[rec.n-1]);
vmess("Receivers at gridpoint z-range iz=%d - %d", rec.z[0], rec.z[rec.n-1]);
vmess(" which are actual positions z=%.2f - %.2f", mod.z0+rec.zr[0], mod.z0+rec.zr[rec.n-1]);
}
coordsx.x = shot.x[ixshot]*mod.dx;
coordsx.z = shot.z[izshot]*mod.dz;
coordsx.y = 0;
t1=wallclock_time();
tio += t1-t2;
if (!strcmp(method,"jesper")) {
#pragma omp parallel for default(shared) \
private (coordgx,irec,Time,Jr)
for (irec=0; irec<rec.n; irec++) {
coordgx.x=rec.xr[irec];
coordgx.z=rec.zr[irec];
coordgx.y = 0;
getWaveParameter(slowness, grid, mod.dx, coordsx, coordgx, ray, &Time, &Jr);
time[((izshot*shot.nx)+ixshot)*rec.n + irec] = Time.x + Time.y + 0.5*Time.z;
ampl[((izshot*shot.nx)+ixshot)*rec.n + irec] = Jr;
if (verbose>4) vmess("JS: shot=%f,%f receiver at %f,%f T0=%f T1=%f T2=%f Jr=%f",coordsx.x, coordsx.z, coordgx.x, coordgx.z, Time.x, Time.y, Time.z, Jr);
}
}
else if(!strcmp(method,"fd")) {
int mzrcv;
isrc.x = shot.x[ixshot];
isrc.y = 0;
isrc.z = shot.z[izshot];
mzrcv = 0;
for (irec = 0; irec < rec.n; irec++) mzrcv = MAX(rec.z[irec], mzrcv);
vidale(ttime,slowness,&isrc,grid,mod.dx,sbox, mzrcv);
for (irec=0; irec<rec.n; irec++) {
coordgx.x=mod.x0+rec.xr[irec];
coordgx.z=mod.z0+rec.zr[irec];
coordgx.y = 0;
ipos = ((izshot*shot.nx)+ixshot)*rec.n + irec;
time[ipos] = ttime[rec.z[irec]*mod.nx+rec.x[irec]];
/* compute average velocity between source and receiver */
nrx = (rec.x[irec]-isrc.x);
nrz = (rec.z[irec]-isrc.z);
nr = abs(nrx) + abs(nrz);
cp_average = 0.0;
for (ir=0; ir<nr; ir++) {
ix = isrc.x + floor((ir*nrx)/nr);
iz = isrc.z + floor((ir*nrz)/nr);
//fprintf(stderr,"ir=%d ix=%d iz=%d velocity=%f\n", ir, ix, iz, velocity[ix*mod.nz+iz]);
cp_average += velocity[ix*mod.nz+iz];
}
cp_average = cp_average/((float)nr);
ampl[ipos] = sqrt(time[ipos]*cp_average);
if (verbose>4) vmess("FD: shot=%f,%f receiver at %f(%d),%f(%d) T=%e V=%f Ampl=%f",coordsx.x, coordsx.z, coordgx.x, rec.x[irec], coordgx.z, rec.z[irec], time[ipos], cp_average, ampl[ipos]);
}
}
t2=wallclock_time();
tray += t2-t1;
hdr.sx = 1000*(mod.x0+mod.dx*shot.x[ixshot]);
hdr.sdepth = 1000*(mod.z0+mod.dz*shot.z[izshot]);
hdr.selev = (int)(-1000.0*(mod.z0+mod.dz*shot.z[izshot]));
hdr.fldr = ((izshot*shot.nx)+ixshot)+1;
hdr.tracl = ((izshot*shot.nx)+ixshot)+1;
hdr.tracf = ((izshot*shot.nx)+ixshot)+1;
hdr.ntr = shot.n;
hdr.dt = (unsigned short)1;
hdr.trwf = shot.n;
hdr.ns = rec.n;
//hdr.d1 = (rec.x[1]-rec.x[0])*mod.dx; // discrete
hdr.d1 = (rec.xr[1]-rec.xr[0]);
hdr.f1 = mod.x0+rec.x[0]*mod.dx;
hdr.d2 = (shot.x[MIN(shot.n-1,1)]-shot.x[0])*mod.dx;
hdr.f2 = mod.x0+shot.x[0]*mod.dx;
dt_tmp = (fabs(hdr.d1*((float)hdr.scalco)));
hdr.dt = (unsigned short)dt_tmp;
nwrite = fwrite( &hdr, 1, TRCBYTES, fpt);
assert(nwrite == TRCBYTES);
nwrite = fwrite( &time[((izshot*shot.nx)+ixshot)*rec.n], sizeof(float), rec.n, fpt);
assert(nwrite == rec.n);
fflush(fpt);
if (ray.geomspread) {
nwrite = fwrite( &hdr, 1, TRCBYTES, fpa);
assert(nwrite == TRCBYTES);
nwrite = fwrite( &l[((izshot*shot.nx)+ixshot)*rec.n], sizeof(float), rec.n, fpa);
assert(nwrite == rec.n);
fflush(fpa);
}
if (file_rcvtime != NULL) {
hdr.ns = rec.nt;
hdr.trwf = rec.n;
hdr.ntr = ((izshot*shot.nx)+ixshot+1)*rec.n;
hdr.dt = dt*1000000;
hdr.d1 = dt;
hdr.f1 = 0.0;
hdr.d2 = (rec.xr[1]-rec.xr[0]);
hdr.f2 = mod.x0+rec.x[0]*mod.dx;
for (irec=0; irec<rec.n; irec++) {
ipos = ((izshot*shot.nx)+ixshot)*rec.n + irec;
hdr.tracf = irec+1;
hdr.tracl = ((izshot*shot.nx)+ixshot*shot.nz)+irec+1;
hdr.gx = 1000*(mod.x0+rec.xr[irec]);
hdr.offset = (rec.xr[irec]-shot.x[ixshot]*mod.dx);
hdr.gelev = (int)(-1000*(mod.z0+rec.zr[irec]));
tr = time[ipos]+rdelay;
for (ig=0; ig<nfreq; ig++) {
cmute[ig].r = (cwav[ig].r*cos(ig*dw*tr-M_PI/4.0)-cwav[ig].i*sin(ig*dw*tr-M_PI/4.0))/(ntfft*ampl[ipos]);
cmute[ig].i = (cwav[ig].i*cos(ig*dw*tr-M_PI/4.0)+cwav[ig].r*sin(ig*dw*tr-M_PI/4.0))/(ntfft*ampl[ipos]);
}
cr1fft(cmute,wavelet,ntfft,-1);
nwrite = fwrite( &hdr, 1, TRCBYTES, fprcv);
nwrite = fwrite( wavelet, sizeof(float), rec.nt, fprcv );
}
}
t1=wallclock_time();
tio += t1-t2;
} /* end of ixshot loop */
} /* end of loop over number of shots */
fclose(fpt);
if (file_rcvtime != NULL) fclose(fprcv);
if (ray.geomspread) fclose(fpa);
t1= wallclock_time();
if (verbose) {
vmess("*******************************************");
vmess("************* runtime info ****************");
vmess("*******************************************");
vmess("Total compute time ray-tracing = %.2f s.", t1-t0);
vmess(" - intializing arrays and model = %.3f", tinit);
vmess(" - ray tracing = %.3f", tray);
vmess(" - writing data to file = %.3f", tio);
}
/* free arrays */
initargs(argc,argv); /* this will free the arg arrays declared */
free(velocity);
free(slowness);
return 0;
}
/* main program */
main(int argc, char **argv)
{
float min, max; /* scale */
double dtmp, tmp, dmin, dmax;
int nt; /* number of samples per trace */
int it; /* time index */
FILE *infp=stdin, *outfp=stdout;
int itrace;
int nbad, ibad, report_good, action;
char *printout;
FILE *printfp;
float fmax, fmin;
int *count, itmp, i;
float *plots;
double rms, rmssum;
float rmsout, scale;
int imute, ntrace;
int itmin, itmax, its;
/* initialize */
initargs(argc, argv); /* initialize parameter reading */
askdoc(1); /* on-line self documentation */
/* parameters fetching */
if (!getparfloat("min",&min)) min=0.0;
if (!getparfloat("max",&max)) max=1.0e+6;
if (!getparint("report",&report_good)) report_good=0;
if (!getparint("action",&action)) action=0;
if (!getparstring("printout",&printout)) {
printfp = stderr;
} else {
printfp = fopen(printout,"w");
}
if (action==3) {
if(!getparfloat("rmsout",&rmsout))
err(" rmsout missing ");
}
/* processing */
file2g(infp);
if (!fgettr(infp,&trin)) err("can't get first trace");
/* read in the first trace, exit if fail */
nt = trin.ns; /* obtain number of samples per trace */
if(action!=0) file2g(outfp);
if (!getparint("itmin",&itmin)) itmin = 0;
if (!getparint("itmax",&itmax)) itmax = nt;
dmin = min;
dmax = max;
nbad = 0;
itrace=1;
fmax = 0.;
fmin = 1.e+38;
count = (int*) malloc(40*sizeof(int));
plots = (float*) malloc(160*sizeof(float));
bzero(count,40*sizeof(int));
bzero(plots,160*sizeof(float));
rmssum = 0.;
ntrace = 0;
/* Main loop over traces */
do {
ibad = 0;
rms = 0.;
if(itmin==0) {
imute = (trin.mute - trin.delrt)*1000/(int)trin.dt;
if(imute<0) imute=0;
its = imute;
} else {
its = itmin;
}
for(it=its;it<nt;it++) {
if( !ieeefinite(&trin.data[it]) ) {
ibad += 1;
if(action==1) trin.data[it] = 0.;
count[39] += 1;
} else {
rms = rms + trin.data[it]*trin.data[it];
dtmp = trin.data[it];
tmp = fabs(dtmp);
if(tmp<dmin || tmp>dmax) {
ibad += 1;
if(action==1) trin.data[it] = 0.;
}
if(tmp>fmax) {
fmax = tmp;
} else if (tmp<fmin) {
fmin = tmp;
}
if(dtmp>0.) {
dtmp = log10(tmp);
itmp = dtmp;
} else {
itmp = 0;
}
if(itmp<0) {
itmp = 0;
} else if(itmp>38) {
itmp = 39;
}
count[itmp] += 1;
}
}
if(nt>its) {
rms = sqrt(rms/(nt-its));
}
if(ibad>0 && action==2) bzero((char*)trin.data,nt*4);
if( (ibad>0 || rms>rmsout) && action==3) {
if(rms==0) {
bzero((char*)trin.data,nt*4);
} else {
scale = rmsout/rms;
for(it=0;it<nt;it++) trin.data[it] *=scale;
}
}
if(ibad>0) nbad += 1;
/* report */
if(ibad>0) {
fprintf(printfp,
"BAD amplitude at trace %d with trace number=%d rms=%g \n",
itrace,trin.tracl,rms);
} else if(report_good == 1) {
fprintf(printfp,
"GOOD amplitude at trace %d with trace number=%d rms=%g\n",
itrace,trin.tracl,rms);
} else if(action==3 && rms>rmsout) {
fprintf(printfp,
"BAD rms amplitude at trace %d with trace number=%d rms=%g \n",
itrace,trin.tracl,rms);
}
fflush(printfp);
itrace +=1;
if(action!=0) fputtr(outfp,&trin);
rmssum += rms;
ntrace += 1;
} while (fgettr(infp,&trin)); /* reading traces */
if( ntrace>1) rmssum = rmssum / ntrace;
fprintf(printfp,
"===> Total Number of Bad Traces in Input = %d \n",nbad);
fprintf(printfp,
"===> Maximum Absolute Amplitude in Input = %g \n",fmax);
fprintf(printfp,
"===> Minimum Absolute Amplitude in Input = %g \n",fmin);
fprintf(printfp,
"===> average trace rms amplitude in Input = %g \n",rmssum);
itmp = 0;
for(i=0;i<40;i++) itmp += count[i];
for(i=0;i<40;i++) {
plots[i*4] = i;
plots[i*4+1] = (float)count[i]/(float)itmp*100.;
plots[i*4+2] = i+1;
plots[i*4+3] = (float)count[i]/(float)itmp*100.;
}
for(i=0;i<39;i++) {
if(count[i]>0) {
if(i==0) {
tmp = 0.;
} else {
tmp = pow(10.,(float)i);
}
fprintf(printfp,
"===> Percentage of Amplitudes from %g to %g =%-5.2f \n",
tmp, pow(10.,(float)(i+1)),
(float)count[i]/(float)itmp*100.);
}
}
if(count[39]>0) fprintf(printfp,
"===> Percentage of Infinity/NaN Amplitudes =%-5.2f \n",
(float)count[39]/(float)itmp*100.);
itmp = 80;
dump2xgraph(plots,&itmp,1,"Input Amplitude Distribution","power of 10",
"percentage","normal");
free(count);
free(plots);
return 0;
}
int main(int argc, char **argv) /*argc, argv - the arguments to the main() function*/
{
int nt; /*number of time samples*/
int nz; /*number of migrated depth samples*/
int nx; /*number of midpoints (traces)*/
int ix;
int iz;
float dt; /*time sampling interval*/
float dx; /*spatial sampling interval*/
float dz; /*migrated depth sampling interval*/
float **data; /*input seismic data*/
complex **image; /*migrated image*/
float **rimage; /*migrated image*/
float **v; /*velocity model*/
FILE *vfp;
char *vfile=""; /*name of velocity file*/
int verbose=1;
char *tmpdir; /* directory path for tmp files*/
cwp_Bool istmpdir=cwp_false; /* true for user-given path*/
/******************************* Intialize *********************************************/
initargs(argc,argv);
requestdoc(1);
/********************************* Get parameters **************************************/
/*get info from first trace*/
if (!gettr(&tr)) err("can't get first trace"); /*fgettr: get a fixed-length segy trace from a file by file pointer*/
nt = tr.ns; /*nt*/ /*gettr: macro using fgettr to get a trace from stdin*/
if (!getparfloat("dt", &dt)) { /*dt*/
if (tr.dt) {
dt = ((double) tr.dt)/1000000.0;
}
else {err("dt is not set");}
}
if (!getparfloat("dx", &dx)) { /*dx*/
if (tr.d2) {
dx = tr.d2;
}
else {
err("dx is not set");
}
}
/*get optional parameters*/
if (!getparint("nz",&nz)) err("nz must be specified");
if (!getparfloat("dz",&dz)) err("dz must be specified");
if (!getparstring("vfile", &vfile)) err("velocity file must be specified");
if (!getparint("verbose", &verbose)) verbose = 0;
/****************************************************************************************/
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
checkpars();
/**************************** Count trace number nx ******************************/
/* store traces and headers in tempfiles while getting a count */
if (STREQ(tmpdir,"")) {
tracefp = etmpfile();
headerfp = etmpfile();
if (verbose) warn("using tmpfile() call");
}
else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(tracefile, temporary_filename(directory));
strcpy(headerfile, temporary_filename(directory));
/* Trap signals so can remove temp files */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
tracefp = efopen(tracefile, "w+");
headerfp = efopen(headerfile, "w+");
istmpdir=cwp_true;
if (verbose) warn("putting temporary files in %s", directory);
}
nx = 0;
do {
++nx; /*get the number of traces nx*/
efwrite(&tr,HDRBYTES,1,headerfp);
efwrite(tr.data, FSIZE, nt, tracefp);
} while (gettr(&tr));
erewind(tracefp); /*Set position of stream to the beginning*/
erewind(headerfp);
/******************************************************************************************/
/*allocate memory*/
data = alloc2float(nt,nx); /*2D array nx by nt*/
image = alloc2complex(nz,nx); /*2D array nx by nz*/
rimage = alloc2float(nz,nx); /*2D array nx by nz*/
v= alloc2float(nz,nx); /*2D array, in Fortran the velocity model is nz by nx 2D array*/
/*in binary, it is actually 1D*/
/* load traces into the zero-offset array and close tmpfile */
efread(*data, FSIZE, nt*nx, tracefp); /*read traces to data*/
efclose(tracefp);
/*load velicoty file*/
vfp=efopen(vfile,"r");
efread(v[0],FSIZE,nz*nx,vfp); /*load velocity*/
efclose(vfp);
/***********************finish reading data*************************************************/
/* call pspi migration function*/
pspimig(data,image,v,nt,nx,nz,dt,dx,dz);
/*get real part of image*/
for (iz=0;iz<nz;iz++){
for (ix=0;ix<nx;ix++){
rimage[ix][iz] = image[ix][iz].r;
}
}
/* restore header fields and write output */
for (ix=0; ix<nx; ix++) {
efread(&tr,HDRBYTES,1,headerfp);
tr.ns = nz;
tr.d1 = dz;
memcpy( (void *) tr.data, (const void *) rimage[ix],nz*FSIZE);
puttr(&tr);
}
/* Clean up */
efclose(headerfp);
if (istmpdir) eremove(headerfile);
if (istmpdir) eremove(tracefile);
return(CWP_Exit());
}
int main(int argc, char **argv) {
int gelev_vmin, gelev_vmax, selev_vmin, selev_vmax;
int gelev_min, gelev_max, selev_min, selev_max;
int gelev_globalmin, gelev_globalmax, selev_globalmin, selev_globalmax;
int gelev_num, selev_num;
int imin, iminv, ifirst, nz1, nz, ns, ntr, ntrv, nsv;
double dfirst, delrt, delrtv, twt, dt, dtv, factor, z, amp_out;
double *depth, *tr_amp;
float ***velocity;
short verbose;
register int i, j, k, l;
cwp_String vfile;
FILE *fv;
initargs(argc, argv);
requestdoc (0);
if (!getparshort("verbose", &verbose)) verbose = 1;
if (!getparstring("vfile",&vfile)) vfile = "output.su";
ntr = gettra (&tr, 0);
fv = efopen (vfile, "r");
ntrv = fgettra (fv, &vtr, 0);
delrt = tr.delrt;
delrtv = vtr.delrt;
if (!getparint("ns", &ns)) ns = tr.ns;
if (!getparint("nsv", &nsv)) nsv = vtr.ns;
if (!getparint("nz", &nz)) nz=2000;
dt = tr.dt * 0.001;
dtv = vtr.dt * 0.001;
imin = nint ( delrt / dt );
iminv = nint ( delrtv / dtv );
depth = ealloc1double ( ns );
tr_amp = ealloc1double ( ns );
factor = 0.0005;
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "Number of input traces = %d\n", ntr );
fprintf ( stderr, "Number of input samples per trace = %d\n", ns );
fprintf ( stderr, "Number of output samples per trace = %d\n", nz );
fprintf ( stderr, "Sample rate = %f ms.\n", dt );
fprintf ( stderr, "Average velocity SU file name = %s\n", vfile );
fprintf ( stderr, "Number of VAVG input traces = %d\n", ntrv );
fprintf ( stderr, "Number of VAVG input samples per trace = %d\n", nsv );
fprintf ( stderr, "VAVG Sample rate = %f ms.\n", dtv );
fprintf ( stderr, "Input Delay = %f ms., First sample = %d\n", delrt, imin );
fprintf ( stderr, "Velocity Delay = %f ms., First sample = %d\n", delrtv, iminv );
fprintf ( stderr, "\n" );
}
rewind ( fv );
gelev_vmin = selev_vmin = INT_MAX;
gelev_vmax = selev_vmax = INT_MIN;
for ( i = 0; i < ntrv; ++i ) {
fgettr (fv, &vtr);
gelev_vmin = min ( gelev_vmin, vtr.gelev );
gelev_vmax = max ( gelev_vmax, vtr.gelev );
selev_vmin = min ( selev_vmin, vtr.selev );
selev_vmax = max ( selev_vmax, vtr.selev );
}
if ( verbose ) fprintf ( stderr, "VELOCITY DATA - gelev_vmin = %d, gelev_vmax = %d, selev_vmin = %d, selev_vmax = %d\n", gelev_vmin, gelev_vmax, selev_vmin, selev_vmax );
rewind (stdin);
gelev_min = selev_min = INT_MAX;
gelev_max = selev_max = INT_MIN;
for ( i = 0; i < ntr; ++i ) {
gettr (&tr);
gelev_min = min ( gelev_min, tr.gelev );
gelev_max = max ( gelev_max, tr.gelev );
selev_min = min ( selev_min, tr.selev );
selev_max = max ( selev_max, tr.selev );
}
if ( verbose ) fprintf ( stderr, "INPUT DATA - gelev_min = %d, gelev_max = %d, selev_min = %d, selev_max = %d\n", gelev_min, gelev_max, selev_min, selev_max );
gelev_globalmin = max ( gelev_min, gelev_vmin );
selev_globalmin = max ( selev_min, selev_vmin );
gelev_globalmax = min ( gelev_max, gelev_vmax );
selev_globalmax = min ( selev_max, selev_vmax );
gelev_num = gelev_globalmax - gelev_globalmin + 1;
selev_num = selev_globalmax - selev_globalmin + 1;
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "gelev_globalmin = %d, gelev_globalmax = %d, selev_globalmin = %d, selev_globalmax = %d\n", gelev_globalmin, gelev_globalmax, selev_globalmin, selev_globalmax );
fprintf ( stderr, "gelev_num = %d, selev_num = %d\n", gelev_num, selev_num );
}
velocity = ealloc3float ( nsv, selev_num, gelev_num );
rewind ( fv );
ifirst = 0;
dfirst = 9999999999999999.9;
for ( k = 0; k < ntrv; ++k ) {
fgettr (fv, &vtr);
if ( vtr.gelev >= gelev_globalmin && vtr.gelev <= gelev_globalmax && vtr.selev >= selev_globalmin && vtr.selev <= selev_globalmax ) {
i = vtr.gelev - gelev_globalmin;
j = vtr.selev - selev_globalmin;
memcpy( (void *) &velocity[i][j][0], (const void *) &vtr.data, nsv * FSIZE );
dfirst = min ( dfirst, velocity[i][j][0] * delrtv * factor );
}
}
efclose (fv);
ifirst = nint ( dfirst / dt );
nz1 = nz - ifirst;
if ( verbose ) fprintf ( stderr, "ifirst = %d, dfirst = %f, nz1 = %d\n", ifirst, dfirst, nz1 );
float zero;
double depth_max;
zero = 0.0;
rewind (stdin);
for ( l = 0; l < ntr; ++l ) {
gettr (&tr);
if ( tr.gelev >= gelev_globalmin && tr.gelev <= gelev_globalmax && tr.selev >= selev_globalmin && tr.selev <= selev_globalmax ) {
i = tr.gelev - gelev_globalmin;
j = tr.selev - selev_globalmin;
for ( k = 0; k < nsv; ++k ) {
twt = ( k * dtv ) + delrtv;
tr_amp[k] = tr.data[k+iminv];
depth[k] = velocity[i][j][k] * twt * factor;
}
depth_max = depth[nsv-1];
fprintf ( stderr, "trace number = %5d, depth_max = %f\n", l, depth_max );
for ( k=ifirst; k < nz1; ++k ) {
z = k * dt;
if ( z <= depth_max ) {
dintlin ( nsv, depth, tr_amp, tr_amp[0], tr_amp[nsv-1], 1, &z, &_out );
tr.data[k-ifirst] = (float) amp_out;
} else {
tr.data[k-ifirst] = zero;
}
}
tr.trid = 1;
tr.ns = nsv;
tr.delrt = nint ( dfirst );
tr.dt = nint(dt*1000);
puttr (&tr);
}
}
free1double (tr_amp);
free1double (depth);
free3float (velocity);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
int nx,nz,ix,iz,verbose;
float tmp;
float **c11,**c13,**c33,**c44,**vp,**vs,**rho,**eps, **delta;
/* input files */
char *c11_file, *c13_file, *c33_file, *c44_file;
FILE *c11fp, *c13fp, *c33fp, *c44fp;
/* output files */
char *vp_file,*vs_file,*rho_file,*eps_file,*delta_file;
FILE *vpfp,*vsfp,*rhofp,*epsfp,*deltafp;
/* hook up getpar */
initargs(argc, argv);
requestdoc(1);
/* get required parameters */
MUSTGETPARINT("nx", &nx );
MUSTGETPARINT("nz", &nz );
/* get parameters */
if (!getparstring("rho_file", &rho_file)) rho_file="rho.bin";
if (!getparstring("c11_file", &c11_file)) c11_file="c11.bin";
if (!getparstring("c13_file", &c13_file)) c13_file="c13.bin";
if (!getparstring("c33_file", &c33_file)) c33_file="c33.bin";
if (!getparstring("c44_file", &c44_file)) c44_file="c44.bin";
if (!getparstring("vp_file", &vp_file)) vp_file="vp.bin";
if (!getparstring("vs_file", &vs_file)) vs_file="vs.bin";
if (!getparstring("eps_file", &eps_file)) eps_file="eps.bin";
if (!getparstring("delta_file", &delta_file)) delta_file="delta.bin";
if (!getparint("verbose", &verbose)) verbose = 1;
checkpars();
/* allocate space */
rho = alloc2float(nz,nx);
c11 = alloc2float(nz,nx);
c13 = alloc2float(nz,nx);
c33 = alloc2float(nz,nx);
c44 = alloc2float(nz,nx);
vp = alloc2float(nz,nx);
vs = alloc2float(nz,nx);
eps = alloc2float(nz,nx);
delta = alloc2float(nz,nx);
/* read mandatory input files */
rhofp = efopen(rho_file,"r");
if (efread(*rho, sizeof(float), nz*nx, rhofp)!=nz*nx)
err("error reading rho_file=%s!\n",rho_file);
c11fp = efopen(c11_file,"r");
if (efread(*c11, sizeof(float), nz*nx, c11fp)!=nz*nx)
err("error reading c11_file=%s!\n",c11_file);
c13fp = efopen(c13_file,"r");
if (efread(*c13, sizeof(float), nz*nx, c13fp)!=nz*nx)
err("error reading c13_file=%s!\n",c13_file);
c33fp = efopen(c33_file,"r");
if (efread(*c33, sizeof(float), nz*nx, c33fp)!=nz*nx)
err("error reading c33_file=%s!\n",c33_file);
c44fp = efopen(c44_file,"r");
if (efread(*c44, sizeof(float), nz*nx, c44fp)!=nz*nx)
err("error reading c44_file=%s!\n",c44_file);
fclose(rhofp);
fclose(c11fp);
fclose(c13fp);
fclose(c33fp);
fclose(c44fp);
/* open output file: */
vpfp = fopen(vp_file,"w");
vsfp = fopen(vs_file,"w");
epsfp = fopen(eps_file,"w");
deltafp = fopen(delta_file,"w");
/* loop over gridpoints and do calculations */
for(ix=0; ix<nx; ++ix){
for(iz=0; iz<nz; ++iz){
vp[ix][iz] = sqrt(c33[ix][iz]/rho[ix][iz]);
vs[ix][iz] = sqrt(c44[ix][iz]/rho[ix][iz]);
eps[ix][iz] = (c11[ix][iz]-c33[ix][iz])/(2*c33[ix][iz]);
tmp = (c13[ix][iz]+c44[ix][iz])*(c13[ix][iz]+c44[ix][iz]);
tmp = tmp - (c33[ix][iz]-c44[ix][iz])*(c33[ix][iz]-c44[ix][iz]);
delta[ix][iz] = tmp/(2*c33[ix][iz]*(c33[ix][iz]-c44[ix][iz]));
}
}
/* write the output files to disk */
efwrite(*vp,sizeof(float),nz*nx,vpfp);
efwrite(*vs,sizeof(float),nz*nx,vsfp);
efwrite(*eps,sizeof(float),nz*nx,epsfp);
efwrite(*delta,sizeof(float),nz*nx,deltafp);
if(verbose){
warn("Output file for vp : %s ",vp_file);
warn("Output file for vs : %s ",vs_file);
warn("Output file for epsilon : %s ",eps_file);
warn("Output file for delta : %s ",delta_file);
}
/* free workspace */
free2float(vp);
free2float(vs);
free2float(rho);
free2float(eps);
free2float(delta);
free2float(c11);
free2float(c13);
free2float(c33);
free2float(c44);
return(CWP_Exit());
}
int
main(int argc, char **argv) {
cwp_String op="mult"; /* operation: add, sub, ..., */
int iop=MULT; /* integer abbrev. for op in switch */
int nt; /* number of samples on input trace */
float a;
int copy, j, tracl;
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get information from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
tracl = tr.tracl;
/* Get operation, recall iop initialized to the default FABS */
getparstring("op", &op);
if (STREQ(op, "add")) iop = ADD;
else if (STREQ(op, "sub")) iop = SUB;
else if (STREQ(op, "div")) iop = DIV;
else if (STREQ(op, "pow")) iop = POW;
else if (STREQ(op, "spow")) iop = SPOW;
else if (!STREQ(op, "mult"))
err("unknown operation=\"%s\", see self-doc", op);
if (!getparfloat("a", &a)) a = 1;
if (!getparint("copy", ©)) copy = 1;
if (copy > 1) tracl = 1;
/* Main loop over traces */
do {
switch(iop) { register int i;
case ADD:
for (i = 0; i < nt; ++i)
tr.data[i] += a;
break;
case SUB:
for (i = 0; i < nt; ++i)
tr.data[i] -= a;
break;
case MULT:
for (i = 0; i < nt; ++i)
tr.data[i] *= a;
break;
case DIV:
for (i = 0; i < nt; ++i)
tr.data[i] /= a;
break;
case POW:
for (i = 0; i < nt; ++i)
tr.data[i] = pow(tr.data[i],a);
break;
case SPOW:
for (i = 0; i < nt; ++i)
tr.data[i] = SGN(tr.data[i])*pow(ABS(tr.data[i]),a);
break;
default: /* defensive programming */
err("mysterious operation=\"%s\"", op);
} /* end scope of i */
if (copy == 1) {
puttr(&tr);
} else {
for (j = 1; j <= copy; ++j) {
tr.tracl = tracl;
puttr(&tr);
++tracl;
}
}
} while (gettr(&tr));
return(CWP_Exit());
}
int
main(int argc, char **argv)
{
int nz; /* numer of depth samples */
int iz; /* counter */
int nt; /* number of time samples */
int nzpar; /* number of getparred depth values for velocities */
int nvpar; /* number of getparred velocity values */
int izpar; /* counter */
int verbose; /* verbose flag, =0 silent, =1 chatty */
float dz=0.0; /* depth sampling interval */
float fz=0.0; /* first depth value */
float dt=0.0; /* time sampling interval for velocities */
float ft=0.0; /* first time value */
float z=0.0; /* depth values for times */
float vmin=0.0; /* minimum velocity */
float vmax=0.0; /* maximum velocity */
float *zpar=NULL; /* values of z getparred */
float *vpar=NULL; /* values of v getparred */
float *vz=NULL; /* v(z) velocity as a function of z */
float *zt=NULL; /* z(t) depth as a function of t */
float *temp=NULL; /* temporary storage array */
char *vfile=""; /* name of the velocity file */
/* hook up getpar */
initargs(argc,argv);
requestdoc(1);
/* get time sampling from first header */
if (!gettr(&tr)) err("can't get first trace");
nz = tr.ns;
/* get depth sampling */
if (!getparfloat("dz",&dz)) dz = ((float) tr.d1);
/* determine velocity function v(t) */
vz = ealloc1float(nz);
if (!getparstring("vfile",&vfile)) {
nzpar = countparval("z");
if (nzpar==0) nzpar = 1;
zpar = ealloc1float(nzpar);
if (!getparfloat("z",zpar)) zpar[0] = 0.0;
nvpar = countparval("v");
if (nvpar==0) nvpar = 1;
if (nvpar!=nzpar)err("number of t and v values must be equal");
vpar = ealloc1float(nvpar);
if (!getparfloat("v",vpar)) vpar[0] = 1500.0;
for (izpar=1; izpar<nzpar; ++izpar)
if (zpar[izpar]<=zpar[izpar-1])
err("zpar must increase monotonically");
for (iz=0,z=0.0; iz<nz; ++iz,z+=dz)
intlin(nzpar,zpar,vpar,vpar[0],vpar[nzpar-1],
1,&z,&vz[iz]);
} else { /* read from a file */
if (fread(vz,sizeof(float),nz,fopen(vfile,"r"))!=nz)
err("cannot read %d velocities from file %s",nz,vfile);
}
/* determine minimum and maximum velocities */
for (iz=1,vmin=vmax=vz[0]; iz<nz; ++iz) {
if (vz[iz]<vmin) vmin = vz[iz];
if (vz[iz]>vmax) vmax = vz[iz];
}
/* get parameters */
if (!getparfloat("dt",&dt)) dt = 2.0*dz/vmin;
if (!getparfloat("ft",&ft)) ft = 2.0*ft/vz[0];
if (!getparint("nt",&nt)) nt = 1+(nz-1)*dz*2.0/(dt*vmax);
if (!getparint("verbose",&verbose)) verbose = 0;
CHECK_NT("nt",nt);
/* if requested, print time sampling, etc */
if (verbose) {
warn("Input:");
warn("\tnumber of depth samples = %d",nz);
warn("\tdepth sampling interval = %g",dz);
warn("\tfirst depth sample = %g",fz);
warn("Output:");
warn("\tnumber of time samples = %d",nt);
warn("\ttime sampling interval = %g",dt);
warn("\tfirst time sample = %g",ft);
}
/* allocate workspace */
zt = ealloc1float(nt);
temp = ealloc1float(nz);
/* make z(t) function */
makezt(nz,dz,fz,vz,nt,dt,ft,zt);
/* loop over traces */
do {
/* update header fields */
tr.trid = TREAL;
tr.ns = nt;
tr.dt = dt*1000000.0;
tr.f1 = ft;
tr.d1 = 0.0;
/* resample */
memcpy((void *) temp, (const void *) tr.data,nz*sizeof(float));
ints8r(nz,dz,fz,temp,0.0,0.0,nt,zt,tr.data);
/* put this trace before getting another */
puttr(&tr);
} while(gettr(&tr));
return(CWP_Exit());
}
int
main(int argc, char **argv)
{
int nx,nz;
float fx,fz,dx,dz,xs,zs,ex,ez,**v,**t,**a,**sg,**bet;
FILE *vfp=stdin,*tfp=stdout,*afp,*sfp,*bfp;
char *bfile="", *sfile="", *afile="";
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(0);
/* get required parameters */
if (!getparint("nx",&nx)) err("must specify nx!\n");
if (!getparint("nz",&nz)) err("must specify nz!\n");
if (!getparfloat("xs",&xs)) err("must specify xs!\n");
if (!getparfloat("zs",&zs)) err("must specify zs!\n");
/* get optional parameters */
if (!getparfloat("dx",&dx)) dx = 1.0;
if (!getparfloat("fx",&fx)) fx = 0.0;
if (!getparfloat("dz",&dz)) dz = 1.0;
if (!getparfloat("fz",&fz)) fz = 0.0;
if (!getparstring("sfile",&sfile)) sfile = "sfile";
if (!getparstring("bfile",&bfile)) bfile = "bfile";
if (!getparstring("afile",&afile)) afile = "afile";
checkpars();
if ((sfp=fopen(sfile,"w"))==NULL)
err("cannot open sfile=%s",sfile);
if ((bfp=fopen(bfile,"w"))==NULL)
err("cannot open bfile=%s",bfile);
if ((afp=fopen(afile,"w"))==NULL)
err("cannot open afile=%s",afile);
/* ensure source is in grid */
ex = fx+(nx-1)*dx;
ez = fz+(nz-1)*dz;
if (fx>xs || ex<xs || fz>zs || ez<zs)
err("source lies outside of specified (x,z) grid\n");
/* allocate space */
v = alloc2float(nz,nx);
t = alloc2float(nz,nx);
sg = alloc2float(nz,nx);
a = alloc2float(nz,nx);
bet = alloc2float(nz,nx);
/* read velocities */
fread(v[0],sizeof(float),nx*nz,vfp);
/* compute times, angles, sigma, and betas */
eiktam(xs,zs,nz,dz,fz,nx,dx,fx,v,t,a,sg,bet);
/* write first-arrival times */
fwrite(t[0],sizeof(float),nx*nz,tfp);
/* write sigma */
fwrite(sg[0],sizeof(float),nx*nz,sfp);
/* write angle */
fwrite(a[0],sizeof(float),nx*nz,afp);
/* write beta */
fwrite(bet[0],sizeof(float),nx*nz,bfp);
/* close files */
fclose(sfp);
fclose(afp);
fclose(bfp);
/* free space */
free2float(v);
free2float(t);
free2float(a);
free2float(sg);
free2float(bet);
return(CWP_Exit());
}
int main (int argc, char **argv) {
char *coeff_x, *coeff_x2, *coeff_x3, file[BUFSIZ];
cwp_Bool active = TRUE;
struct GRD_HEADER grd_x, grd_x2, grd_x3;
struct GMT_EDGEINFO edgeinfo_x, edgeinfo_x2, edgeinfo_x3;
struct GMT_BCR bcr_x, bcr_x2, bcr_x3;
short check, verbose;
int nz, ntr, ns;
double value, scale_factor, dz, x_loc, y_loc;
double weight_x, weight_x2, weight_x3;
double value_coeff_x, value_coeff_x2, value_coeff_x3, tr_sec, dt_sec;
float depth_input, amp_output, *tr_amp, *depth;
register int k, n;
initargs(argc, argv);
argc = GMT_begin (argc, argv);
if (!getparstring("coeff_x", &coeff_x)) {
fprintf ( stderr, "Must supply Coefficient_X GMT grid (COEFF_X Parameter) --> exiting\n" );
return EXIT_FAILURE;
}
if (!getparstring("coeff_x2", &coeff_x2)) {
fprintf ( stderr, "Must supply Coefficient_X2 GMT grid (COEFF_X2 Parameter)--> exiting\n" );
return EXIT_FAILURE;
}
if (!getparstring("coeff_x3", &coeff_x3)) {
fprintf ( stderr, "Must supply Coefficient_X3 GMT grid (COEFF_X3 Parameter)--> exiting\n" );
return EXIT_FAILURE;
}
if (!getparshort("verbose" , &verbose)) verbose = 0;
if (!getpardouble("weight_x", &weight_x)) weight_x = 1.0;
if (!getpardouble("weight_x2", &weight_x2)) weight_x2 = 1.0;
if (!getpardouble("weight_x3", &weight_x3)) weight_x3 = 1.0;
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "X1 Coefficient GMT grid file name = %s\n", coeff_x );
fprintf ( stderr, "X2 Coefficient GMT grid file name = %s\n", coeff_x2 );
fprintf ( stderr, "X3 Coefficient GMT grid file name = %s\n", coeff_x3 );
fprintf ( stderr, "X1 Grid Weighting Value = %f\n", weight_x );
fprintf ( stderr, "X2 Grid Weighting Value = %f\n", weight_x2 );
fprintf ( stderr, "X3 Grid Weighting Value = %f\n", weight_x3 );
fprintf ( stderr, "\n" );
}
weight_x = 1.0 / weight_x;
weight_x2 = 1.0 / weight_x2;
weight_x3 = 1.0 / weight_x3;
GMT_boundcond_init (&edgeinfo_x);
GMT_boundcond_init (&edgeinfo_x2);
GMT_boundcond_init (&edgeinfo_x3);
GMT_grd_init (&grd_x, argc, argv, FALSE);
GMT_grd_init (&grd_x2, argc, argv, FALSE);
GMT_grd_init (&grd_x3, argc, argv, FALSE);
if (GMT_read_grd_info (coeff_x, &grd_x)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x2, &grd_x2)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x3, &grd_x3)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
f1 = (float *) GMT_memory (VNULL, (size_t)((grd_x.nx + 4) * (grd_x.ny + 4)), sizeof(float), GMT_program);
f2 = (float *) GMT_memory (VNULL, (size_t)((grd_x2.nx + 4) * (grd_x2.ny + 4)), sizeof(float), GMT_program);
f3 = (float *) GMT_memory (VNULL, (size_t)((grd_x3.nx + 4) * (grd_x3.ny + 4)), sizeof(float), GMT_program);
GMT_pad[0] = GMT_pad[1] = GMT_pad[2] = GMT_pad[3] = 2;
GMT_boundcond_param_prep (&grd_x, &edgeinfo_x);
GMT_boundcond_param_prep (&grd_x2, &edgeinfo_x2);
GMT_boundcond_param_prep (&grd_x3, &edgeinfo_x3);
GMT_boundcond_set (&grd_x, &edgeinfo_x, GMT_pad, f1);
GMT_boundcond_set (&grd_x2, &edgeinfo_x2, GMT_pad, f2);
GMT_boundcond_set (&grd_x3, &edgeinfo_x3, GMT_pad, f3);
value = 0.0;
GMT_bcr_init (&grd_x, GMT_pad, active, value, &bcr_x);
GMT_bcr_init (&grd_x2, GMT_pad, active, value, &bcr_x2);
GMT_bcr_init (&grd_x3, GMT_pad, active, value, &bcr_x3);
GMT_read_grd (coeff_x, &grd_x, f1, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x2, &grd_x2, f2, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x3, &grd_x3, f3, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
/* Get info from first trace */
ntr = gettra (&tr, 0);
ns = tr.ns;
dt_sec = tr.dt * 0.000001;
scale_factor = tr.scalco;
if (scale_factor < 0.0 ) scale_factor *= -1.0;
if (scale_factor == 0.0 ) scale_factor = 1.0;
if (!getpardouble ("dz",&dz)) dz = 2.0;
if (!getparint ("nz",&nz)) nz = ns;
if ( verbose ) {
fprintf ( stderr, "Output depth sample rate = %f\n", dz );
fprintf ( stderr, "Coordinate scale factor = %f\n", scale_factor );
fprintf ( stderr, "Number of output depth samples per trace = %d\n", nz );
fprintf ( stderr, "number of traces = %d, number of samples per trace = %d\n", ntr, ns );
fprintf ( stderr, "time sample rate (seconds) = %f\n", dt_sec );
}
rewind (stdin);
depth = ealloc1float ( ns );
tr_amp = ealloc1float ( nz );
/* Main loop over traces */
for ( k = 0; k < ntr; ++k ) {
gettr (&tr);
x_loc = tr.sx / scale_factor;
y_loc = tr.sy / scale_factor;
check = 0;
if ( x_loc >= grd_x.x_min && x_loc <= grd_x.x_max && y_loc >= grd_x.y_min && y_loc <= grd_x.y_max ) check = 1;
if ( check ) {
value_coeff_x = GMT_get_bcr_z (&grd_x, x_loc, y_loc, f1, &edgeinfo_x, &bcr_x);
value_coeff_x2 = GMT_get_bcr_z (&grd_x2, x_loc, y_loc, f2, &edgeinfo_x2, &bcr_x2);
value_coeff_x3 = GMT_get_bcr_z (&grd_x3, x_loc, y_loc, f3, &edgeinfo_x3, &bcr_x3);
if ( verbose ) fprintf ( stderr, "Trace num = %d, X-Loc = %f, Y-Loc = %f, X Coefficient = %0.10f, X2 Coefficient = %0.10f, X3 Coefficient = %0.10f\n",
k+1, x_loc, y_loc, value_coeff_x, value_coeff_x2, value_coeff_x3 );
for ( n=0; n < ns; ++n ) {
tr_amp[n] = tr.data[n];
tr_sec = n * dt_sec;
depth[n] = (((value_coeff_x*tr_sec)*weight_x) + ((value_coeff_x2*pow(tr_sec,2))*weight_x2) + ((value_coeff_x3*pow(tr_sec,3))*weight_x3)) * -1.0;
if ( verbose == 2 ) fprintf ( stderr, "Trace no. = %5d, Sample = %5d, TWT (secs.) = %.4f, Depth (feet) = %.4f\n", k, n, tr_sec, depth[n] );
}
for ( n=0; n < nz; ++n ) {
depth_input = n * dz;
intlin ( ns, depth, tr_amp, tr_amp[0], tr_amp[ns-1], 1, &depth_input, &_output );
dtr.data[n] = amp_output;
}
dtr.tracl = tr.tracl;
dtr.tracr = tr.tracr;
dtr.ep = tr.ep;
dtr.ns = nz;
dtr.dt = nint (dz * 1000.0);
dtr.sx = tr.sx;
dtr.sy = tr.sy;
dtr.trid = 1;
dtr.fldr = tr.fldr;
dtr.cdp = tr.cdp ;
puttr (&dtr);
} else {
fprintf ( stderr, "input trace = %d, xloc = %.0f yloc = %.0f is out of bounds\n", k, x_loc, y_loc);
}
}
GMT_free ((void *)f1);
GMT_free ((void *)f2);
GMT_free ((void *)f3);
GMT_end (argc, argv);
free1float (depth);
free1float (tr_amp);
return (0);
}
int main( int argc, char *argv[] )
{
cwp_String keyg; /* header key word from segy.h */
cwp_String typeg; /* ... its type */
Value valg;
cwp_String key[SU_NKEYS]; /* array of keywords */
cwp_String type[SU_NKEYS]; /* array of keywords */
int index[SU_NKEYS]; /* name of type of getparred key */
segy **rec_o; /* trace header+data matrix */
int first=0; /* true when we passed the first gather */
int ng=0;
float dt; /* time sampling interval */
int nt; /* number of time samples per trace */
int ntr; /* number of traces per ensemble */
int nfft=0; /* lenghth of padded array */
float snfft; /* scale factor for inverse fft */
int nf=0; /* number of frequencies */
float d1; /* frequency sampling int. */
float *rt; /* real trace */
complex *ctmix; /* complex trace */
complex **fd; /* frequency domain data */
float padd;
int nd; /* number of dimensions */
float *dx=NULL;
float fac;
float vmin;
int vf;
/* Trimming arrays */
float *itrm=NULL;
float *rtrm=NULL;
float *wht=NULL;
float trimp=15;
/* Initialize */
initargs(argc, argv);
requestdoc(1);
if (!getparstring("keyg", &keyg)) keyg ="ep";
if (!getparint("vf", &vf)) vf = 1;
if (!getparfloat("vmin", &vmin)) vmin = 5000;
if (!getparfloat("padd", &padd)) padd = 25.0;
padd = 1.0+padd/100.0;
/* Get "key" values */
nd=countparval("key");
getparstringarray("key",key);
/* get types and indexes corresponding to the keys */
{ int ikey;
for (ikey=0; ikey<nd; ++ikey) {
type[ikey]=hdtype(key[ikey]);
index[ikey]=getindex(key[ikey]);
}
}
dx = ealloc1float(nd);
MUSTGETPARFLOAT("dx",(float *)dx);
if (!getparfloat("fac", &fac)) fac = 1.0;
fac = MAX(fac,1.0);
/* get the first record */
rec_o = get_gather(&keyg,&typeg,&valg,&nt,&ntr,&dt,&first);
if(ntr==0) err("Can't get first record\n");
/* set up the fft */
nfft = npfar(nt*padd);
if (nfft >= SU_NFLTS || nfft >= PFA_MAX)
err("Padded nt=%d--too big", nfft);
nf = nfft/2 + 1;
snfft=1.0/nfft;
d1 = 1.0/(nfft*dt);
rt = ealloc1float(nfft);
ctmix = ealloc1complex(nf);
do {
ng++;
fd = ealloc2complex(nf,ntr);
memset( (void *) ctmix, (int) '\0', nf*sizeof(complex));
itrm = ealloc1float(ntr);
rtrm = ealloc1float(ntr);
wht = ealloc1float(ntr);
/* transform the data into FX domain */
{ unsigned int itr;
for(itr=0;itr<ntr;itr++) {
memcpy( (void *) rt, (const void *) (*rec_o[itr]).data,nt*FSIZE);
memset( (void *) &rt[nt], (int) '\0', (nfft - nt)*FSIZE);
pfarc(1, nfft, rt, fd[itr]);
}
}
/* Do the mixing */
{ unsigned int imx=0,itr,ifr;
float dist;
/* Find the trace to mix */
for(itr=0;itr<ntr;itr++)
if((*rec_o[itr]).mark) {
imx = itr;
break;
}
memcpy( (void *) ctmix, (const void *) fd[imx],nf*sizeof(complex));
/* Save the header */
memcpy( (void *) &tr, (const void *) rec_o[imx],HDRBYTES);
/* weights */
wht[imx] = 1.0;
for(itr=0;itr<imx;itr++) {
dist=n_distance(rec_o,index,type,dx,nd,imx,itr);
wht[itr] = MIN(1.0/dist,1.0);
wht[itr] = 1.0;
}
for(itr=imx+1;itr<ntr;itr++) {
dist=n_distance(rec_o,index,type,dx,nd,imx,itr);
wht[itr] = MIN(1.0/dist,1.0);
wht[itr] = 1.0;
}
/* Do the alpha trim for each trace */
for(ifr=0;ifr<nf;ifr++) {
for(itr=0;itr<ntr;itr++) {
itrm[itr] = fd[itr][ifr].i;
rtrm[itr] = fd[itr][ifr].r;
}
ctmix[ifr].i = alpha_trim_w(itrm,wht,ntr,trimp);
ctmix[ifr].r = alpha_trim_w(rtrm,wht,ntr,trimp);
}
}
{ unsigned int it;
pfacr(-1, nfft, ctmix, rt);
for(it=0;it<nt;it++)
tr.data[it]=rt[it]*snfft;
}
free2complex(fd);
{ unsigned int itr;
for(itr=0;itr<ntr;itr++) {
free1((void *)rec_o[itr]);
}
}
puttr(&tr);
rec_o = get_gather(&keyg,&typeg,&valg,&nt,&ntr,&dt,&first);
fprintf(stderr," %d %d\n",ng,ntr);
free1float(rtrm);
free1float(itrm);
free1float(wht);
} while(ntr);
free1float(rt);
warn("Number of gathers %10d\n",ng);
return EXIT_SUCCESS;
}
