int main(int argc, char **argv) { FILE *fp; int fd,j=0,verbose; initargs(argc,argv); requestdoc(1); if(!getparint("fd",&fd)) fd=-1; if(!getparint("verbose",&verbose)) verbose=0; warn("File descriptor passed to suget = %d",fd); if( (fp = (FILE *) fdopen(fd,"r"))==NULL) err("Bad file descriptor"); warn("About to read first trace"); if(!fgettr(fp,&tr)) err("Can't get first trace"); do{ if(verbose>0){ warn("read trace %d",j); j++; } puttr(&tr); } while(fgettr(fp,&tr)); return(CWP_Exit()); }
/* initialize movie object */ void MovieInit(void) { { extern int _alloc; movie = (Movie) malloc((1) * sizeof(movie[0])); _alloc += (1) * sizeof(movie[0]); if( movie == 0 ){ err("cant allocate %d bytes for movie; %d already allocated", (1) * sizeof(movie[0]), _alloc); } if( memwatch ){ (void) printf("malloc %s=%d\n", " movie", (1) * sizeof(movie[0])); } }; movie->dir = MOVIE_REVERSE; movie->run = 0; movie->delay = 0; movie->cache = 0; getparint("dir", &movie->dir); getparint("run", &movie->run); getparint("delay", &movie->delay); getparint("cache", &movie->cache); }
int main(int argc, char **argv) { int i; /* counter */ int itr=0; /* trace counter */ int verbose; /* =0 silent, =1 chatty */ int interp; /* =1 interpolate to get NaN */ /* and Inf replacement values */ float value; /* value to set NaN and Infs to */ /* Initialize */ initargs(argc,argv); requestdoc(1); /* Get info from first trace */ if(!gettr(&tr) ) err("Can't get first trace \n"); /* Get parameters */ if(!getparint("verbose",&verbose)) verbose = 1; if(!getparint("interp",&interp)) interp = 0; if(!getparfloat("value",&value)) value = 0.0; checkpars(); /* Loop over traces */ do{ ++itr; for(i=0; i<tr.ns; ++i){ if(!isfinite(tr.data[i])) { if (verbose) warn("found NaN trace = %d sample = %d", itr, i); if (interp) { /* interpolate nearest neighbors */ /* for NaN replacement value */ if (i==0 && isfinite(tr.data[i+1])) { tr.data[i]=tr.data[i+1]; } else if(i==tr.ns-1 && isfinite(tr.data[i-2])) { tr.data[i]= tr.data[i-2]; } else if( isfinite(tr.data[i-1]) && isfinite(tr.data[i+1]) ) { tr.data[i]=(tr.data[i-1]+tr.data[i+1])/2.0; } } /* use user defined NaNs replacement value */ tr.data[i] = value; } } puttr(&tr); } while(gettr(&tr)); return(CWP_Exit()); }
int main(int argc, char **argv) { int nt; /* number of samples on input */ int ntout; /* number of samples on output */ int it; /* counter */ int istart; /* beginning sample */ int izero; /* - istart */ int norm; /* user defined normalization value */ int sym; /* symmetric plot? */ float scale; /* scale factor computed from norm */ float *temp=NULL; /* temporary array */ float dt; /* time sampling interval (sec) */ /* hook up getpar */ initargs(argc, argv); requestdoc(1); /* get information from the first header */ if (!gettr(&tr)) err("can't get first trace"); nt = tr.ns; dt = tr.dt/1000000.0; /* get parameters */ if (!getparint("ntout",&ntout)) ntout=101; if (!getparint("norm",&norm)) norm = 1; if (!getparint("sym",&sym)) sym = 1; checkpars(); /* allocate workspace */ temp = ealloc1float(ntout); /* index of first sample */ if (sym == 0) istart = 0; else istart = -(ntout-1)/2; /* index of sample at time zero */ izero = -istart; /* loop over traces */ do { xcor(nt,0,tr.data,nt,0,tr.data,ntout,istart,temp); if (norm) { scale = 1.0/(temp[izero]==0.0?1.0:temp[izero]); for (it=0; it<ntout; ++it) temp[it] *= scale; } memcpy((void *) tr.data, (const void *) temp, ntout*FSIZE); tr.ns = ntout; tr.f1 = -dt*ntout/2.0; tr.delrt = 0; puttr(&tr); } while(gettr(&tr)); return(CWP_Exit()); }
int main( int argc, char *argv[] ) { /* binning */ float xc; float yc; double cdpcx; double cdpcy; float dbx; float dby; float deg; float degr; int dirx; int diry; int nx; int ny; float xe; float ye; int ix; int iy; initargs(argc, argv); requestdoc(1); /* binning stuff */ if(!getparfloat("xc",&xc)) xc=1; if(!getparfloat("yc",&yc)) yc=1; if(!getparfloat("dbx",&dbx)) dbx=20; if(!getparfloat("dby",&dby)) dby=20; if(!getparfloat("deg",°)) deg=0; degr = 3.141592653/180 * deg; if(!getparint("dirx",&dirx)) dirx=1; if(!getparint("diry",&diry)) diry=1; MUSTGETPARINT("nx", &nx); MUSTGETPARINT("ny", &ny); /* edge of bin# 1,1 */ xe = xc - dirx*dbx/2.0*cos(degr) - diry*dby/2.0*sin(degr); ye = yc - diry*dby/2.0*cos(degr) + dirx*dbx/2.0*sin(degr); /* compute bin centre coordinates */ for(ix=1;ix<=nx; ix++) { for(iy=1;iy<=ny;iy++) { cdpcx= xc + dirx*(ix-1)*dbx*cos(degr) + diry*(iy-1)*dby*sin(degr); cdpcy= yc + diry*(iy-1)*dby*cos(degr) - dirx*(ix-1)*dbx*sin(degr); fprintf(stdout," %d %f %f\n", ix*1000+iy,cdpcx,cdpcy); } } return EXIT_SUCCESS; }
int main(int argc, char **argv) { int itmin; /* smallest sample (zero-based) to plot */ int itmax; /* largest sample (zero-based) to plot */ int nt; /* number of samples */ int count; /* number of traces to plot */ register int itr; /* trace counter */ cwp_Bool plotall; /* plot all the traces */ /* Initialize */ initargs(argc, argv); requestdoc(1); /* Set number of traces to plot */ plotall = cwp_false; if (!getparint("count", &count)) plotall = cwp_true; /* Loop over traces */ for (itr = 0; (plotall || itr < count) && gettr(&tr); itr++) { nt = (int) tr.ns; /* Cast from unsigned */ if (itr == 0) { /* Awkward to do a gettr outside loop */ if (!getparint("itmin", &itmin)) itmin = 0; if (!getparint("itmax", &itmax)) itmax = nt - 1; if (itmin >= nt - 1 || itmin < 0) { err("itmin=%d, require 0 < itmin < %d", itmin, nt - 1); } if (itmax >= nt) { itmax = nt - 1; } if (itmax < 0) { err("itmax=%d, require itmax > 0", itmax); } if (itmin > itmax) { itmin = itmax; } } printheader(&tr); tabplot(&tr, itmin, itmax); } return(CWP_Exit()); }
int main( int argc, char *argv[] ) { /* Segy data constans */ int nt; /* number of time samples */ int ntr=0; /* number of traces */ float *filter; int fnl,fnr; int fnp; int fld; int fm; float dt; /* sample interval in secs */ float prw; /* pre-withening */ initargs(argc, argv); requestdoc(1); /* get information from the first header */ if (!gettr(&tr)) err("can't get first trace"); nt = tr.ns; if (!getparfloat("dt", &dt)) dt = ((double) tr.dt)/1000000.0; if (!dt) { dt = .002; warn("dt not set, assumed to be .002"); } if(!getparint ("fnl", &fnl)) fnl=15; fnr=fnl; if(!getparint ("fnp", &fnp)) fnp=fnr+fnl+fnr/2; if(!getparfloat ("prw", &prw)) prw=1.0; if(fnl!=0) { fld=0; fm=0; fnr=fnl; filter = ealloc1float(fnp); SG_smoothing_filter(fnp,fnl,fnr,fld,fm,filter); /* rwa_smoothing_filter(1,fnl,fnr,filter); */ } else { filter= NULL; } do { do_minphdec(tr.data,nt,filter,fnl,fnr,prw); tr.ns=nt; ntr++; puttr(&tr); } while(gettr(&tr)); return EXIT_SUCCESS; }
int main(int argc, char **argv) { int nt,nshot,noff; int ishot,ioff,it; float dt,dshot,doff,sx,gx,offset,cmp; /* Initialize */ initargs(argc, argv); requestdoc(0); /* stdin not used */ nt = 100; getparint("nt", &nt); CHECK_NT("nt",nt); tr.ns = nt; nshot = 10; getparint("nshot", &nshot); noff = 24; getparint("noff", &noff); dt = 0.004; getparfloat("dt", &dt); tr.dt = dt*1000000; dshot = 10; getparfloat("dshot", &dshot); doff = 20; getparfloat("doff", &doff); for (ishot = 0; ishot < nshot; ishot++) { sx = ishot*dshot; for (ioff = 0; ioff < noff; ioff++) { offset = (ioff+1)*doff; gx = sx + offset; cmp = (sx + gx)/2.; memset( (void *) tr.data, 0, nt * FSIZE); for (it = 0; it < nt/4; it++) { tr.data[it] = sx; } for (it = nt/4; it < nt/2; it++) { tr.data[it] = gx; } for (it = nt/2; it < 3*nt/4; it++) { tr.data[it] = offset; } for (it = 3*nt/4; it < nt; it++) { tr.data[it] = cmp; } tr.sx = sx; tr.gx = gx; tr.offset = offset; tr.cdp = cmp; tr.tracl = ishot*nshot + ioff + 1; puttr(&tr); } } return(CWP_Exit()); }
int main(int argc, char **argv) { int ns; /* samples on output traces */ /* Initialize */ initargs(argc, argv); requestdoc(1); /* Get info from first trace */ if (!fvgettr(stdin, &tr)) err("can't get first trace"); if (!getparint("ns", &ns)) ns = tr.ns; checkpars(); /* Loop over the traces */ do { int nt = tr.ns; if (nt < ns) /* pad with zeros */ memset((void *)(tr.data + nt), 0, (ns-nt)*FSIZE); tr.ns = ns; puttr(&tr); } while (fvgettr(stdin, &tr)); 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()); }
/* Value getpar -- omitted string type for now */ void getparval(String name, String type, int n, Value *valp) { register int k; short *h; unsigned short *u; long *l; unsigned long *v; int *i; unsigned int *p; float *f; double *d; switch(*type) { case 'h': h = (short*) ealloc1(n, sizeof(short)); getparshort(name, h); for (k = 0; k < n; ++k) valp[k].h = h[k]; break; case 'u': u = (unsigned short*) ealloc1(n, sizeof(unsigned short)); getparushort(name, u); for (k = 0; k < n; ++k) valp[k].u = u[k]; break; case 'l': l = (long*) ealloc1(n, sizeof(long)); getparlong(name, l); for (k = 0; k < n; ++k) valp[k].l = l[k]; break; case 'v': v = (unsigned long*) ealloc1(n, sizeof(unsigned long)); getparulong(name, v); for (k = 0; k < n; ++k) valp[k].v = v[k]; break; case 'i': i = (int*) ealloc1(n, sizeof(int)); getparint(name, i); for (k = 0; k < n; ++k) valp[k].i = i[k]; break; case 'p': p = (unsigned int*) ealloc1(n, sizeof(unsigned int)); getparuint(name, p); for (k = 0; k < n; ++k) valp[k].p = p[k]; break; case 'f': f = (float*) ealloc1(n, sizeof(float)); getparfloat(name, f); for (k = 0; k < n; ++k) valp[k].f = f[k]; break; case 'd': d = (double*) ealloc1(n, sizeof(double)); getpardouble(name, d); for (k = 0; k < n; ++k) valp[k].d = d[k]; break; default: err("getparval: %d: mysterious type %s", __LINE__, type); } }
main(int argc, char **argv) { int n1,i1,n2,i2; float *trace; float tmp; float fama,fami; FILE *infp=stdin; long long l2; /* get parameters */ initargs(argc,argv); askdoc(1); if (!getparint("n1",&n1)) err("must specify n1! \n"); if (!getparint("n2",&n2)) { fseek2g(infp,0L,2); l2 = ftell2g(infp); l2 = l2/sizeof(float)/n1; n2 = l2; fseek2g(infp,0L,0); } trace = (float*)malloc(n1*sizeof(float)); for (i2=0;i2<n2;i2++) { fread(trace,sizeof(float),n1,infp); if (i2==0) { tmp = trace[0]; if ( tmp < 0. ) tmp = - tmp; fama = tmp; fami = tmp; } for(i1=0;i1<n1;i1++) { tmp = trace[i1]; if(tmp < 0. ) tmp = -tmp; if ( fama < tmp ) fama = tmp; if ( fami > tmp ) fami = tmp; } } printf("max abs value= %f \n",fama); printf("min abs value= %f \n",fami); }
int main( int argc, char *argv[] ) { int n1; /* number of x y values */ int stinc; /* x increment */ int f; /* filter length */ int m; /* filter method flag */ float *x; /* array of x index values */ float *y; /* array of y values */ /* Initialize */ initargs(argc, argv); requestdoc(1); MUSTGETPARINT("n1",&n1); if( !getparint("stinc",&stinc)) stinc=1; if( !getparint("f",&f)) f=5; if( !getparint("m",&m)) m=1; /* allocate arrays */ x = ealloc1float(n1); y = ealloc1float(n1); /* Read data into the arrays */ { int i; for(i=0;i<n1;i++) { fscanf(stdin," %f %f\n",&x[i],&y[i]); } } /* smooth */ sm_st(x,y,n1,f,stinc,m); /* Write out */ { int i; for(i=0;i<n1;i++) { fprintf(stdout," %10.3f %10.3f\n",x[i],y[i]); } } free1float(x); free1float(y); 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) { int j,nt,flag,ntout; float *buf,*ttn,dt,dtout=0.0,tmin,tmax; /* Initialize */ initargs(argc, argv); requestdoc(1); /* Get information from the first header */ if (!gettr(&tr)) err("can't get first trace"); nt = tr.ns; dt = (float) tr.dt/1000000.0; if (!getparfloat("tmin", &tmin)) tmin=0.1*nt*dt; if (!getparint("flag", &flag)) flag=1; if(flag==1) { dtout=tmin*2.*dt; tmax=nt*dt; ntout=1+tmax*tmax/dtout; CHECK_NT("ntout",ntout); ttn=ealloc1float(ntout); for(j=0;j<ntout;j++) ttn[j]=sqrt(j*dtout); }else{ if (!getparfloat("dt", &dt)) dtout=0.004; ntout=1+sqrt(nt*dt)/dtout; CHECK_NT("ntout",ntout); ttn=ealloc1float(ntout); for(j=0;j<ntout;j++) ttn[j]=j*j*dtout*dtout; } buf = ealloc1float(nt); fprintf(stderr,"sutsq: ntin=%d dtin=%f ntout=%d dtout=%f\n", nt,dt,ntout,dtout); /* Main loop over traces */ do { for(j=0;j<nt;j++) buf[j]=tr.data[j]; tr.ns = ntout; tr.dt = dtout*1000000.; ints8r(nt,dt,0.,buf,0.0,0.0, ntout,ttn,tr.data); puttr(&tr); } while (gettr(&tr)); return(CWP_Exit()); }
int main(int argc, char **argv) { int itmin; /* first sample to zero out */ int itmax; /* last sample to zero out */ float value; /* value to set within window */ int nt; /* time samples per trace in input data */ /* Initialize */ initargs(argc, argv); requestdoc(1); /* Get information from first trace */ if (!gettr(&tr)) err("can't get first trace"); nt = tr.ns; /* Get params from user */ MUSTGETPARINT("itmax", &itmax); if (!getparint("itmin", &itmin)) itmin = 0; if (!getparfloat("value", &value)) value = 0.0; /* Error checking */ if (itmax > nt) err("itmax = %d, must be < nt", itmax); if (itmin < 0) err("itmin = %d, must not be negative", itmin); if (itmax < itmin) err("itmax < itmin, not allowed"); /* Main loop over traces */ do { register int i; for (i = itmin; i <= itmax; ++i) tr.data[i] = value; puttr(&tr); } while(gettr(&tr)); return(CWP_Exit()); }
int main(int argc, char **argv) { int i; int j; int bins; float min; float max; float bin; int* histogram; /* Initialize */ initargs(argc, argv); requestdoc(1); /* Get info from first trace */ if( !gettr(&tr) ){ err("Can't get first trace \n"); } /* Get parameters */ if( !getparfloat("min", &min) ){ err("min must be specified\n"); } if( !getparfloat("max", &max) ){ err("max must be specified\n"); } if( !getparint("bins", &bins) ){ err("bins must be specified\n"); } bin = (max-min) / bins; histogram=emalloc( bins*sizeof(int) ); /* Loop over traces */ do{ for( i=0; i<tr.ns; i++ ){ j = (tr.data[i] - min) / bin; j = j < 0 ? 0 : j; j = j > bins-1 ? bins-1 : j; histogram[j]++; } }while( gettr(&tr) ); for( i=0; i<bins; i++ ){ printf( "%15f " ,min+i*bin ); printf( "%15d " ,histogram[i] ); printf( "\n" ); } 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) { 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) { register float *rt; /* real trace */ register float *mt; /* magnitude trace */ register float *ct; /* resampled centroid trace */ int nt; /* number of points on input trace */ int verbose; /* flag to get advisory messages */ float dt; /* sampling interval in secs */ float invdt; /* inverse dt */ float hdt; /* half dt */ cwp_Bool inflect=cwp_false; /* inflection point flag */ cwp_Bool zero_cross=cwp_false; /* zero-crossing flag */ cwp_Bool max_passed=cwp_false; /* maximum value passed flag */ float *time; /* array of trace sample time values */ float sum_amp; /* sum of amplitudes in lobe */ float t_cen; /* centroid about amplitude axis */ int isamp; /* t_cen time sample number */ float a_cen; /* centroid about time axis */ float a_mom; /* moment about time axis */ float t_mom; /* moment about amplitude axis */ float a_height; /* height of region for moment calc */ float t_width; /* width of region for moment calc */ int first; /* number of first sample in lobe */ int last; /* number of last sample in lobe */ int prev; /* number of past sample in amp moment */ int small; /* sample number of current smaller mag */ int nvals; /* number of samples in current lobe */ int nvals_min; /* minimum samples in lobe for inclusion*/ int i,k; /* counter indices */ /* Initialize */ initargs(argc, argv); requestdoc(1); if (!getparint("verbose", &verbose)) verbose=1; if (!getparint("nvals_min", &nvals_min)) nvals_min = 1; /* Get info from first trace */ if (!gettr(&tr)) err("can't get first trace"); nt = tr.ns; /* dt is used only to set output header value d1 */ if (!getparfloat("dt", &dt)) dt = ((double) tr.dt)/1000000.0; if (!dt) { dt = .004; if (verbose) warn("dt not set, assumed to be .004"); } invdt = 1.0 / dt; hdt = 0.5 * dt; /* Allocate space */ rt = ealloc1float(nt); ct = ealloc1float(nt); mt = ealloc1float(nt); time = ealloc1float(nt); /* create an array of times */ for (i = 0; i < nt; ++i) { time[i] = (float)(i + 1) * dt; } /* Main loop over traces */ do { register int i; /* Load trace into rt and zero ct */ memcpy((void *) rt, (const void *) tr.data, nt*FSIZE); memset((void *) ct, 0, nt*FSIZE); first = 0; mt[0] = fabs(rt[0]); sum_amp = rt[0]; t_mom = time[0] * mt[0]; for (i = 1; i < nt; ++i) { mt[i] = fabs(rt[i]); /* test for zero-crossing or inflection point */ if(rt[i] * rt[i-1] > (float)0) { if(mt[i] > mt[i-1]) { if(max_passed) inflect = cwp_true; } else { max_passed = cwp_true; } } else { zero_cross = cwp_true; } /* if a zero-crossing or inflection point is not */ /* encountered on the current trace sample, */ /* accumulate the time moment */ /* and sum of the lobe amplitude */ if(!zero_cross && !inflect) { sum_amp = sum_amp + rt[i]; t_mom = t_mom + (time[i] * mt[i]); } else { /* otherwise a zero-crossing or inflection has */ /* occured, so stop and determine amplitude */ /* centroid and store results as a centroid */ /* sample for the current lobe */ /* determine the amplitude centroid */ last = i - 1; /* if inflection point has been found divide it */ /* between the calcs for this lobe and the next */ if (inflect) { last = i; rt[last] = rt[last] * 0.5; mt[last] = fabs(rt[last]); sum_amp = sum_amp + rt[last]; t_mom = t_mom + (time[last] * mt[last]); } nvals = last - first + 1; if(nvals == 1) { /* check to see if lobe is big enough */ /* to be included */ if(nvals >= nvals_min) { ct[i] = rt[i] * 0.5; } first = i; inflect = cwp_false; max_passed = cwp_false; zero_cross = cwp_false; sum_amp = rt[i]; t_mom = time[i] * mt[i]; } else { a_height = mt[first]; if(mt[first] > mt[last]) { a_height = mt[last]; } t_width = time[last] - time[first] + dt; a_mom = a_height * 0.5; a_cen = t_width * a_height * a_mom; small = first; if (mt[first] > mt[last]) small = last; for (k = 1; k < nvals; k ++) { prev = small; if (prev == first) first = first + 1; else last = last - 1; small = first; if(mt[first] > mt[last]) small = last; a_height = rt[small] - rt[prev]; a_mom = rt[prev] + (a_height * 0.5); t_width = t_width - dt; a_cen = a_cen + a_mom*t_width*a_height; } if(sum_amp == 0.0) { warn("i = %d, sum_amp = %f,divide by zero !", i,sum_amp); } a_cen = a_cen / (sum_amp * dt); /* determine the time centroid */ t_cen = t_mom / fabs(sum_amp); /* start accumulating amplitude sum */ /* and time moment for next lobe */ sum_amp = rt[i]; t_mom = time[i] * mt[i]; /* set sample corresponding to t_cen */ /* to amplitude a_cen */ isamp = (int) ((t_cen * invdt) + hdt); /* check to see if lobe is big enough */ /* to be included */ if(nvals >= nvals_min) { ct[isamp] = a_cen; } first = i; inflect = cwp_false; max_passed = cwp_false; zero_cross = cwp_false; } /* end if block for case of nvals > 1 */ } /* end calc of new centroid */ } /* end of loop down input trace */ /* Store values */ for (i = 0; i < nt; ++i) { tr.data[i] = ct[i]; } /* Set header values and write centroid trace */ tr.ns = nt; puttr(&tr); } while (gettr(&tr)); return(CWP_Exit()); }
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) { 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) { 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; }
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) { 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()); }
/* 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; }
main(int argc, char **argv) { char *cbuf; int n1, n2, i, nxin, jv, icdpnow, icdp; int icmax,ic,nvt; float ivelo,itime; FILE *infp=stdin,*outfp=stdout; float time4[4], velo4[4]; float s,l; float *times, *vrms; int ns, nl, incdp, itmp, is, il, ocdp; float os,ol,ds,dl; int cdpnum=0; int cdptype=0, cdplbl, cdplbls, cdplblx, ocdplbls=1, ocdplblx=1; int dcdplbls=1, dcdplblx=1; int line=0, iline=0, ilinenow=0; int sposhvel=0, lposhvel=0; float snow, lnow; float *fbuf; /* get parameters */ initargs(argc,argv); askdoc(1); if (!getparint("sposhvel",&sposhvel)) sposhvel=0; if(sposhvel!=0) { if(sposhvel<2 || sposhvel>10) err(" check sposhvel=%d must be >=2 and <=10 \n",sposhvel); } if (!getparint("lposhvel",&lposhvel)) lposhvel=0; if(lposhvel!=0) { if(lposhvel<2 || lposhvel>10) err(" check lposhvel=%d must be >=2 and <=10 \n",lposhvel); } if(lposhvel==0 || sposhvel==0) { if (!getparfloat("os",&os)) err("must specify os"); if (!getparfloat("ol",&ol)) err("must specify ol"); if (!getparfloat("ds",&ds)) err("must specify ds"); if (!getparfloat("dl",&dl)) err("must specify dl"); if (!getparint("cdptype",&cdptype)) cdptype=0; if(cdptype==0) { if (!getparint("ocdp",&ocdp)) err("must specify ocdp"); if (!getparint("ns",&ns)) err("must specify ns"); if (!getparint("nl",&nl)) err("must specify nl"); if (!getparint("incdp",&incdp)) err("must specify incdp"); if (!getparint("cdpnum",&cdpnum)) cdpnum = 0; } else { if (!getparint("ocdplbls",&ocdplbls)) ocdplbls=1; if (!getparint("ocdplblx",&ocdplblx)) ocdplblx=1; if (!getparint("dcdplbls",&dcdplbls)) dcdplbls=1; if (!getparint("dcdplblx",&dcdplblx)) dcdplblx=1; } if (!getparint("line",&line)) line=0; } /* memory allocation */ if (!getparint("ntvmax",&n1)) n1=256; if (!getparint("nvfmax",&n2)) n2=4096; icmax = n1 * n2 ; icdpnow = 0; iline = -99999; nxin = 0; cbuf = (char*)malloc(81*sizeof(char)); times = (float*)malloc(n1*sizeof(float)); vrms = (float*)malloc(n1*sizeof(float)); fbuf = (float*)malloc(9*sizeof(float)); jv = 0; fprintf(outfp, "1--4----------16------24------32------40------48------56------64------72 \n"); fprintf(outfp, "CARD S L t1 v1 t2 v2 t3 v3 \n"); fprintf(outfp,"\n"); /* read input reflectivity file */ for (ic=0;ic<icmax;ic++) { if (feof(infp) !=0 ) break; for(i=0;i<81;i++) cbuf[i]=' '; gets(cbuf); if(line==1) { if ( cbuf[0]=='*' && cbuf[1]=='*' && cbuf[2]=='l' && cbuf[3]=='i' &&cbuf[4]=='n' && cbuf[5]=='e' ) sscanf(cbuf+6,"%d",&iline); } if ( cbuf[0]=='H' && cbuf[1]=='A' && cbuf[2]=='N' && cbuf[3]=='D' && cbuf[4]=='V' && cbuf[5]=='E' && cbuf[6]=='L' ) { if(sposhvel==0 || lposhvel==0) { icdp = 0; sscanf(cbuf+8,"%d",&icdp); if(icdp==0) err("cdp number can not be zero"); if (icdpnow == 0 ) { icdpnow = icdp; if(line==1) ilinenow = iline; } } else { sscanf(cbuf+8,"%f %f %f %f %f %f %f %f %f ", &fbuf[0],&fbuf[1],&fbuf[2],&fbuf[3], &fbuf[4],&fbuf[5],&fbuf[6],&fbuf[7],&fbuf[8]); snow = fbuf[sposhvel-2]; lnow = fbuf[lposhvel-2]; icdp = snow; iline = lnow; if(icdpnow == 0) { s = snow; l = lnow; icdpnow = icdp; ilinenow = iline; } } } else if(icdpnow!=0 && cbuf[0]!='*' ) { if (icdp != icdpnow || iline !=ilinenow ) { nvt = jv; nxin = nxin + 1; jv = 0; if(sposhvel==0 || lposhvel==0) { if(line==0) { if(cdptype==0) { fprintf(stderr, "HANDVEL-to-VS3D conversion at cdp=%d for %d t-v pairs \n", icdpnow,nvt); itmp = (icdpnow - ocdp)/incdp; if(cdpnum==0) { il = itmp/ns; is = itmp - il * ns; } else { is = itmp/nl; il = itmp - is * nl; } } else { cdplbls = icdpnow/10000; cdplblx = icdpnow - cdplbls*10000; il = (cdplbls-ocdplbls)/dcdplbls; is = (cdplblx-ocdplblx)/dcdplblx; fprintf(stderr, "HANDVEL-to-VS3D conversion at cdplbl=%d il=%d is=%d for %d t-v pairs \n", icdpnow,il+1,is+1,nvt); } } else { is = icdpnow - 1; il = ilinenow - 1; fprintf(stderr, "HANDVEL-to-VS3D conversion at line=%d xline=%d for %d t-v pairs \n", ilinenow,icdpnow,nvt); } s = os + is*ds; l = ol + il*dl; icdpnow = icdp; if(line==1) ilinenow = iline; printvs3d(s,l,nvt,times,vrms,outfp); } else { fprintf(stderr, "HANDVEL-to-VS3D conversion at lpos=%f spos=%f for %d t-v pairs \n", l,s,nvt); icdpnow = icdp; ilinenow = iline; printvs3d(s,l,nvt,times,vrms,outfp); s = snow; l = lnow; } } for(i=0;i<4;i++) { time4[i] = 0.; velo4[i] = -999999.; } sscanf(cbuf,"%f %f %f %f %f %f %f %f", &time4[0],&velo4[0],&time4[1],&velo4[1], &time4[2],&velo4[2],&time4[3],&velo4[3]); for(i=0;i<4;i++) { itime = time4[i]; ivelo = velo4[i]; if (ivelo == -999999.) break; times[jv] = itime; vrms[jv] = ivelo; jv = jv + 1; } } } if (jv>0) { nxin = nxin + 1; nvt = jv; if(sposhvel==0 || lposhvel==0) { if(line==0) { if(cdptype==0) { fprintf(stderr, "HANDVEL-to-VS3D conversion at cdp=%d for %d t-v pairs \n", icdpnow,nvt); itmp = (icdpnow - ocdp)/incdp; if(cdpnum==0) { il = itmp/ns; is = itmp - il * ns; } else { is = itmp/nl; il = itmp - is * nl; } } else { cdplbls = icdpnow/10000; cdplblx = icdpnow - cdplbls*10000; il = (cdplbls-ocdplbls)/dcdplbls; is = (cdplblx-ocdplblx)/dcdplblx; fprintf(stderr, "HANDVEL-to-VS3D conversion at cdplbl=%d il=%d is=%d for %d t-v pairs \n", icdpnow,il+1,is+1,nvt); } } else { is = icdpnow - 1; il = ilinenow - 1; fprintf(stderr, "HANDVEL-to-VS3D conversion at line=%d xline=%d for %d t-v pairs \n", ilinenow,icdpnow,nvt); } s = os + is*ds; l = ol + il*dl; } else { fprintf(stderr, "HANDVEL-to-VS3D conversion at lpos=%f spos=%f for %d t-v pairs \n", l,s,nvt); } printvs3d(s,l,nvt,times,vrms,outfp); } fprintf(stderr,"\n"); fprintf(stderr,"HANDVEL to VS3D conversion done for %d cdps\n",nxin); free(times); free(vrms); free(cbuf); }
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) { 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) { 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()) ; }