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[] ) { /* 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 nt; /* number of time samples */ int ntr; /* number of traces */ int itr; /* trace counter */ int nspk; /* number of spikes */ int it1; /* time of 1st spike */ int ix1; /* position of 1st spike */ int it2; /* time of 2nd spike */ int ix2; /* position of 2nd spike */ int ix3; /* position of 3rd spike */ int it3; /* time of 3rd spike */ int ix4; /* position of 4th spike */ int it4; /* time of 4th spike */ float dt; /* time sampling interval */ float offset; /* offset */ /* Initialize */ initargs(argc, argv); requestdoc(0); /* stdin not used */ nt = 64; getparint("nt", &nt); CHECK_NT("nt",nt); tr.ns = nt; ntr = 32; getparint("ntr", &ntr); dt = 0.004; getparfloat("dt", &dt); tr.dt = dt*1000000; offset = 400; getparfloat("offset", &offset); tr.offset = offset; nspk = 4; getparint("nspk", &nspk); ix1 = ntr/4; getparint("ix1", &ix1); it1 = nt/4; getparint("it1", &it1); ix2 = ntr/4; getparint("ix2", &ix2); it2 = 3*nt/4; getparint("it2", &it2); ix3 = 3*ntr/4; getparint("ix3", &ix3); it3 = nt/4; getparint("it3", &it3); ix4 = 3*ntr/4; getparint("ix4", &ix4); it4 = 3*nt/4; getparint("it4", &it4); for (itr = 0; itr < ntr; itr++) { memset( (void *) tr.data, 0, nt * FSIZE); if (itr == ix1-1) tr.data[it1-1] = 1.0; if (nspk > 1 && itr == ix2-1) tr.data[it2-1] = 1.0; if (nspk > 2 && itr == ix3-1) tr.data[it3-1] = 1.0; if (nspk > 3 && itr == ix4-1) tr.data[it4-1] = 1.0; tr.tracl = itr + 1; puttr(&tr); } 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 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 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); } }
int main(int argc, char **argv) { int i, j, n; float *f, max, step, rstep; float fhist[1024], dev, rdev, ent, error; int hist[1024]; initargs(argc, argv); requestdoc(1); MUSTGETPARINT("n",&n); f = alloc1float(n); fread(f,sizeof(float),n,stdin); for(i=0;i<1024;i++) hist[i] = 0; for(i=0,rdev=0.;i<n;i++) rdev += f[i]*f[i]; rdev = rdev/n; rdev = sqrt(rdev); if(!getparfloat("dev",&dev)) dev = rdev; fprintf(stderr,"dev=%f\n", dev); step = dev*3.464*.01; rstep = 1./step; error = 0.; for(i=0;i<n;i++){ max = f[i]*rstep; error += (NINT(max)*step - f[i])*(NINT(max)*step - f[i]); hist[NINT(max)+512] ++; } error = error/n; error = sqrt(error); error = error/rdev; ent = 0.; for(j=0;j<1024;j++){ fhist[j] = ((float) hist[j])/((float) n); if(hist[j]) ent += fhist[j]*log(fhist[j])/log(2.); } ent = -ent; fprintf(stderr,"entropy of the signal is=%f, average error=%f\n",ent, error); fwrite(fhist,sizeof(float),1024,stdout); return EXIT_SUCCESS; }
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()); }
main(int argc, char **argv) { segytrace tr; FILE *infp=stdin, *outfp=stdout; int it, nt; float *im, tmp1, tmp2, i0; /* get parameters */ initargs(argc,argv); askdoc(1); if(!getparfloat("i0",&i0)) err("must specify i0"); /* large file(s) */ file2g(infp); file2g(outfp); if (!fgettr(infp,&tr)) err("can't get first trace"); nt = tr.ns; im = (float*) emalloc(nt*sizeof(float)); do { im[0] = i0; for(it=1;it<nt;it++) { tmp1 = 1. - tr.data[it-1]; tmp2 = 1. + tr.data[it-1]; if(tmp1==0.) { im[it] = im[it-1]; } else { im[it] = tmp2/tmp1*im[it-1]; } } for(it=0;it<nt;it++) tr.data[it] = im[it]; fputtr(outfp,&tr); } while(fgettr(infp,&tr)); return 0; }
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) { 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 *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()) ; }
/* 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) { 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) /*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) { 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) { 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) { 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; }
main(int argc, char **argv) { char plotcmd[BUFSIZ]; /* build ximage command for popen */ float *trbuf; /* trace buffer */ FILE *datafp; /* fp for trace data file */ FILE *plotfp; /* fp for plot data */ int nt; /* number of samples on trace */ int ntr; /* number of traces */ float d1; /* time/depth sample rate */ float d2; /* trace/dx sample rate */ float f1; /* tmin/zmin */ float f2; /* tracemin/xmin */ bool seismic; /* is this seismic data? */ int panel; /* panel to pick */ int dtype; /* type of display */ int ppos; /* position of the panel */ FILE *infp=stdin; int n3,n2,n1; /* Initialize */ initargs(argc, argv); askdoc(1); /* Get info from headers and first trace */ fgethdr(infp,&ch,&bh); n1 = bh.hns; if(!getparint("ntpp",&n2)) { if (bh.tsort==2) { n2 = bh.fold; } else { n2 = bh.ntrpr; } } if (!fgettr(infp,&tr)) err("can't get first trace"); nt = tr.ns; if ( n1!=nt ) warn("samples/trace in bhdr and trhdr different; trhdr used! \n"); n1 = nt; fseek(infp,0L,2); n3=(ftell(infp)-EBCBYTES-BNYBYTES)/(n1*sizeof(float)+HDRBYTES)/n2; if(n3==0) { n3=1; n2=(ftell(infp)-EBCBYTES-BNYBYTES)/(n1*sizeof(float)+HDRBYTES); warn("less traces were found in input! \n"); } fseek(infp,0L,0); seismic = (tr.trid == 0 || tr.trid == TREAL); if (!getparint("panel", &panel)) panel=1; if (!getparint("dtype", &dtype)) dtype=0; if (!getparfloat("d1", &d1)) { if (seismic) { /* sampling interval in ms or in m (ft) */ if ( tr.dz!=0. ) { d1 = tr.dz; } else if (tr.dt) { d1 = (float) tr.dt / 1000.0; if (tr.dt<1000) d1 = tr.dt; } else { d1 = 0.004 * 1000.; warn("tr.dt not set, assuming dt=4"); } } else { /* non-seismic data */ if (tr.d1) { d1 = tr.d1; } else { d1 = 1.0; warn("tr.d1 not set, assuming d1=1.0"); } } } if (!getparfloat("d2", &d2)) { if(bh.tsort==2) { d2 = tr.offset; } else { d2 = tr.cdp; } } if (!getparfloat("f1", &f1)) { if (seismic) { f1 = (tr.delrt) ? (float) tr.delrt/1000.0 : 0.0; if(tr.delrt<1000) f1=tr.delrt; if(tr.dz!=0.) f1=tr.fz; } else { f1 = (tr.f1) ? tr.f1 : 0.0; } } if (!getparfloat("f2", &f2)) { if (bh.tsort==2) { f2 = tr.offset; } else { f2 = tr.cdp; } } /* Allocate trace buffer */ trbuf = ealloc1float(nt); /* Create temporary "file" to hold data */ datafp = etempfile(NULL); /* Loop over input traces & put them into the data file */ ntr = 0; fseek(infp,EBCBYTES+BNYBYTES+(panel-1)*n2*(n1*sizeof(float)+HDRBYTES),0); for(ntr=0;ntr<n2;ntr++) { if(!fgettr(infp,&tr)) err("get trace error \n"); efwrite(tr.data, FSIZE, nt, datafp); if(ntr==1) { if (bh.tsort==2) { if(!getparfloat("d2",&d2)) d2 = tr.offset-d2; if (!getparint("ppos", &ppos)) ppos = tr.cdp; } else { if(!getparfloat("d2",&d2)) d2 = tr.cdp-d2; if (!getparint("ppos", &ppos)) ppos = tr.offset; } } } /* Set up xipick or xwpick command line */ if ( dtype == 0 ) { sprintf(plotcmd, "mipick n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f ppos=%d", n1, n2, d1, d2, f1, f2, ppos); } else { sprintf(plotcmd, "mwpick n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f ppos=%d", n1, n2, d1, d2, f1, f2, ppos); } 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)) { 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; read data to buf; write buf to plot program */ plotfp = epopen(plotcmd, "w"); rewind(datafp); { register int itr; for (itr = 0; itr < ntr; ++itr) { efread (trbuf, FSIZE, nt, datafp); efwrite(trbuf, FSIZE, nt, plotfp); } } /* Clean up */ epclose(plotfp); efclose(datafp); return EXIT_SUCCESS; }
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()); }
main(int argc, char **argv) { int nt; /* number of points on trace */ float dt; /* time sample interval (sec) */ float *wiener; /* Wiener error filter coefficients */ float pnoise; /* pef additive noise level */ float minlag; /* start of error filter (sec) */ int iminlag; /* ... in samples */ float maxlag; /* end of error filter (sec) */ int imaxlag; /* ... in samples */ int nlag; /* length of error filter in samples */ int ncorr; /* length of corr window in samples */ float *crosscorr; /* right hand side of Wiener eqs */ float *autocorr; /* vector of autocorrelations */ float *spiker; /* spiking decon filter */ float mincorr; /* start time of correlation window */ int imincorr; /* .. in samples */ float maxcorr; /* end time of correlation window */ int imaxcorr; /* .. in samples */ int showspiker; /* flag to display spiking filter */ int showwiener; /* flag to display pred. error filter */ /* Initialize */ initargs(argc, argv); askdoc(1); /* Get info from first trace */ if (!gettr(&intrace)) err("can't get first trace"); nt = intrace.ns; dt = (float)intrace.dt/1000000.0; if (!dt) MUSTGETPARFLOAT ("dt", &dt); /* Get parameters */ if (!getparint("showwiener", &showwiener)) showwiener = 0; if (!getparint("showspiker", &showspiker)) showspiker = 0; if (!getparfloat("pnoise", &pnoise)) pnoise = PNOISE; if (getparfloat("minlag", &minlag)) iminlag = NINT(minlag/dt); else iminlag = 1; if (iminlag < 1) err("minlag=%g too small", minlag); if (getparfloat("maxlag", &maxlag)) imaxlag = NINT(maxlag/dt); else imaxlag = NINT(0.05 * nt); if (imaxlag >= nt) err("maxlag=%g too large", maxlag); if (iminlag >= imaxlag) err("minlag=%g, maxlag=%g", minlag, maxlag); if (getparfloat("mincorr", &mincorr)) imincorr = NINT(mincorr/dt); else imincorr = 0; if (imincorr < 0) err("mincorr=%g too small", mincorr); if (getparfloat("maxcorr", &maxcorr)) imaxcorr = NINT(maxcorr/dt); else imaxcorr = nt-1; if (imaxcorr >= nt) err("maxcorr=%g too large", maxcorr); if (imincorr >= imaxcorr) err("mincorr=%g, maxcorr=%g", mincorr, maxcorr); nlag = imaxlag - iminlag + 1; ncorr = imaxcorr - imincorr + 1; /* Allocate memory */ wiener = ealloc1float(nlag); spiker = ealloc1float(nlag); autocorr = ealloc1float(imaxlag); /* Set pointer to "cross" correlation */ crosscorr = autocorr + iminlag; /* Main loop over traces */ do { static int itr = 0; ++itr; /* Form autocorrelation vector */ xcor(ncorr, imincorr, intrace.data, ncorr, imincorr, intrace.data, imaxlag, 0, autocorr); /* Leave trace alone if autocorr[0] vanishes */ if (autocorr[0] == 0.0) { puttr(&intrace); if (showwiener) warn("NO Wiener filter, trace: %d", itr); if (showspiker) warn("NO spiking decon filter, trace: %d", itr); continue; } /* Whiten */ autocorr[0] *= 1.0 + pnoise; /* Get inverse filter by Wiener-Levinson */ stoepf(nlag, autocorr, crosscorr, wiener, spiker); /* Convolve pefilter with trace - don't do zero multiplies */ { register int i; for (i = 0; i < nt; ++i) { register int j; register int n = MIN(i, imaxlag); register float sum = intrace.data[i]; for (j = iminlag; j <= n; ++j) sum -= wiener[j-iminlag] * intrace.data[i-j]; outtrace.data[i] = sum; } } /* Output filtered trace */ memcpy((char*)&outtrace, (char*)&intrace, HDRBYTES); puttr(&outtrace); /* Show pefilter and/or spiker on request */ if (showwiener) { register int i; warn("Wiener filter, trace: %d", itr); for (i = 0; i < imaxlag; ++i) fprintf(stderr, "%10g%c", wiener[i], (i%6==5 || i==nlag-1) ? '\n' : ' '); } if (showspiker) { register int i; warn("spiking decon filter, trace: %d", itr); for (i = 0; i < nlag; ++i) fprintf(stderr, "%10g%c", spiker[i], (i%6==5 || i==nlag-1) ? '\n' : ' '); } } while (gettr(&intrace)); return EXIT_SUCCESS; }
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; 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()); }
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[] ) { 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; }
long recvPar3D(recPar *rec, float sub_x0, float sub_y0, float sub_z0, float dx, float dy, float dz, long nx, long ny, long nz) { float *xrcv1, *xrcv2, *yrcv1, *yrcv2, *zrcv1, *zrcv2; long i, ix, iy, ir, verbose; float dxrcv, dyrcv, dzrcv, *dxr, *dyr, *dzr; float rrcv, dphi, oxrcv, oyrcv, ozrcv, arcv; double circ, h, a, b, e, s, xr, yr, zr, dr, srun, phase; float xrange, yrange, zrange, sub_x1, sub_y1, sub_z1; long Nx1, Nx2, Ny1, Ny2, Nz1, Nz2, Ndx, Ndy, Ndz, iarray, nrec, nh; long nxrcv, nyrcv, nzrcv, ncrcv, nrcv, ntrcv, *nlxrcv, *nlyrcv; float *xrcva, *yrcva, *zrcva; char* rcv_txt; FILE *fp; if (!getparlong("verbose", &verbose)) verbose = 0; /* Calculate Model Dimensions */ sub_x1=sub_x0+(nx-1)*dx; sub_y1=sub_y0+(ny-1)*dy; sub_z1=sub_z0+(nz-1)*dz; /* Compute how many receivers are defined and then allocate the receiver arrays */ /* Receiver Array */ nxrcv=countparval("xrcva"); nyrcv=countparval("yrcva"); nzrcv=countparval("zrcva"); if (nxrcv!=nzrcv) verr("Number of receivers in array xrcva (%li), yrcva (%li), zrcva(%li) are not equal",nxrcv,nyrcv,nzrcv); if (verbose&&nxrcv) vmess("Total number of array receivers: %li",nxrcv); /* Linear Receiver Arrays */ Nx1 = countparval("xrcv1"); Nx2 = countparval("xrcv2"); Ny1 = countparval("yrcv1"); Ny2 = countparval("yrcv2"); Nz1 = countparval("zrcv1"); Nz2 = countparval("zrcv2"); if (Nx1!=Nx2) verr("Number of receivers starting points in 'xrcv1' (%li) and number of endpoint in 'xrcv2' (%li) are not equal",Nx1,Nx2); if (Ny1!=Ny2) verr("Number of receivers starting points in 'yrcv1' (%li) and number of endpoint in 'yrcv2' (%li) are not equal",Ny1,Ny2); if (Nz1!=Nz2) verr("Number of receivers starting points in 'zrcv1' (%li) and number of endpoint in 'zrcv2' (%li) are not equal",Nz1,Nz2); if (Nx1!=Ny2) verr("Number of receivers starting points in 'xrcv1' (%li) and number of endpoint in 'yrcv2' (%li) are not equal",Nx1,Ny2); if (Nx1!=Nz2) verr("Number of receivers starting points in 'xrcv1' (%li) and number of endpoint in 'zrcv2' (%li) are not equal",Nx1,Nz2); rec->max_nrec=nyrcv*nxrcv; /* no receivers are defined use default linear array of receivers on top of model */ if (!rec->max_nrec && Nx1==0) Nx1=1; // Default is to use top of model to record data if (!rec->max_nrec && Ny1==0) Ny1=1; if (Nx1) { /* Allocate Start & End Points of Linear Arrays */ xrcv1=(float *)malloc(Nx1*sizeof(float)); xrcv2=(float *)malloc(Nx1*sizeof(float)); yrcv1=(float *)malloc(Nx1*sizeof(float)); yrcv2=(float *)malloc(Nx1*sizeof(float)); zrcv1=(float *)malloc(Nx1*sizeof(float)); zrcv2=(float *)malloc(Nx1*sizeof(float)); if (!getparfloat("xrcv1",xrcv1)) xrcv1[0]=sub_x0; if (!getparfloat("xrcv2",xrcv2)) xrcv2[0]=sub_x1; if (!getparfloat("yrcv1",yrcv1)) yrcv1[0]=sub_y0; if (!getparfloat("yrcv2",yrcv2)) yrcv2[0]=sub_y1; if (!getparfloat("zrcv1",zrcv1)) zrcv1[0]=sub_z0; if (!getparfloat("zrcv2",zrcv2)) zrcv2[0]=zrcv1[0]; /* check if receiver arrays fit into model */ for (iarray=0; iarray<Nx1; iarray++) { xrcv1[iarray] = MAX(sub_x0, xrcv1[iarray]); xrcv1[iarray] = MIN(sub_x0+nx*dx,xrcv1[iarray]); xrcv2[iarray] = MAX(sub_x0, xrcv2[iarray]); xrcv2[iarray] = MIN(sub_x0+nx*dx,xrcv2[iarray]); yrcv1[iarray] = MAX(sub_y0, yrcv1[iarray]); yrcv1[iarray] = MIN(sub_y0+ny*dy,yrcv1[iarray]); yrcv2[iarray] = MAX(sub_y0, yrcv2[iarray]); yrcv2[iarray] = MIN(sub_y0+ny*dy,yrcv2[iarray]); zrcv1[iarray] = MAX(sub_z0, zrcv1[iarray]); zrcv1[iarray] = MIN(sub_z0+nz*dz,zrcv1[iarray]); zrcv2[iarray] = MAX(sub_z0, zrcv2[iarray]); zrcv2[iarray] = MIN(sub_z0+nz*dz,zrcv2[iarray]); } /* Crop to Fit Model */ /* Max's addtion still have to check if it has the same fucntionality */ for (iarray=0;iarray<Nx1;iarray++) { if (xrcv1[iarray]<sub_x0) { if (xrcv2[iarray]<sub_x0) { verr("Linear array %li outside model bounds",iarray); } else { vwarn("Cropping element %li of 'xrcv1' (%f) to model bounds (%f)",iarray,xrcv1[iarray],sub_x0); xrcv1[iarray]=sub_x0; } } else if (xrcv1[iarray] > sub_x1) { verr("Linear array %li outside model bounds",iarray); } if ( (xrcv2[iarray] < xrcv1[iarray]) ) { verr("Ill defined linear array %li, 'xrcv1' (%f) greater than 'xrcv2' (%f)",iarray,xrcv1[iarray],xrcv2[iarray]); } else if (xrcv2[iarray]>sub_x1) { vwarn("Cropping element %li of 'xrcv2' (%f) to model bounds (%f)",iarray,xrcv2[iarray],sub_x1); xrcv2[iarray]=sub_x1; } if (yrcv1[iarray]<sub_y0) { if (yrcv2[iarray]<sub_y0) { verr("Linear array %li outside model bounds",iarray); } else { vwarn("Cropping element %li of 'yrcv1' (%f) to model bounds (%f)",iarray,yrcv1[iarray],sub_y0); yrcv1[iarray]=sub_y0; } } else if (yrcv1[iarray] > sub_y1) { verr("Linear array %li outside model bounds",iarray); } if ( (yrcv2[iarray] < yrcv1[iarray]) ) { verr("Ill defined linear array %li, 'yrcv1' (%f) greater than 'yrcv2' (%f)",iarray,yrcv1[iarray],yrcv2[iarray]); } else if (yrcv2[iarray]>sub_y1) { vwarn("Cropping element %li of 'yrcv2' (%f) to model bounds (%f)",iarray,yrcv2[iarray],sub_y1); yrcv2[iarray]=sub_y1; } if (zrcv1[iarray] < sub_z0) { if (zrcv2[iarray] < sub_z0) { verr("Linear array %li outside model bounds",iarray); } else { vwarn("Cropping element %li of 'zrcv1' (%f) to model bounds (%f)",iarray,zrcv1[iarray],sub_z0); zrcv1[iarray]=sub_z0; } } else if (zrcv1[iarray] > sub_z1) { verr("Linear array %li outside model bounds",iarray); } if ( (zrcv2[iarray] < zrcv1[iarray]) ) { verr("Ill defined linear array %li, 'zrcv1' (%f) greater than 'zrcv2' (%f)",iarray,zrcv1[iarray],zrcv2[iarray]); } else if (zrcv2[iarray]>sub_z1) { vwarn("Cropping element %li of 'xrcv2' (%f) to model bounds (%f)",iarray,zrcv2[iarray],sub_z1); zrcv2[iarray]=sub_z1; } } /* Get Sampling Rates */ Ndx = countparval("dxrcv"); Ndy = countparval("dyrcv"); Ndz = countparval("dzrcv"); dxr = (float *)malloc(Nx1*sizeof(float)); dyr = (float *)malloc(Nx1*sizeof(float)); dzr = (float *)malloc(Nx1*sizeof(float)); if(!getparfloat("dxrcv", dxr)) dxr[0]=dx; if(!getparfloat("dyrcv", dyr)) dyr[0]=dy; if(!getparfloat("dzrcv", dzr)) dzr[0]=0.0; if ( (Ndx<=1) && (Ndy<=1) && (Ndz==0) ){ /* default values are set */ for (i=1; i<Nx1; i++) { dxr[i] = dxr[0]; dyr[i] = dyr[0]; dzr[i] = dzr[0]; } Ndx=1; Ndy=1; Ndz=1; } else if ( (Ndz==1) && (Ndx==0) && (Ndy==0) ){ /* default values are set */ for (i=1; i<Nx1; i++) { dxr[i] = dxr[0]; dyr[i] = dyr[0]; dzr[i] = dzr[0]; } Ndz=1; Ndy=1; Ndx=1; } else { /* make sure that each array has dzrcv or dxrcv defined for each line or receivers */ if (Ndx!=Ndz) { verr("Number of 'dxrcv' (%li) is not equal to number of 'dzrcv' (%li) or 1",Ndx,Ndz); } if (Ndx!=Ndy) { verr("Number of 'dxrcv' (%li) is not equal to number of 'dyrcv' (%li) or 1",Ndx,Ndy); } if (Ndx!=Nx1 && Ndx!=1) { verr("Number of 'dxrcv' (%li) is not equal to number of starting points in 'xrcv1' (%li) or 1",Ndx,Nx1); } if (Ndy!=Ny1 && Ndy!=1) { verr("Number of 'dyrcv' (%li) is not equal to number of starting points in 'yrcv1' (%li) or 1",Ndy,Ny1); } } /* check consistency of receiver steps */ for (iarray=0; iarray<Ndx; iarray++) { if (dxr[iarray]<0) { dxr[i]=dx; vwarn("'dxrcv' element %li (%f) is less than zero, changing it to %f'",iarray,dxr[iarray],dx); } } for (iarray=0; iarray<Ndy; iarray++) { if (dyr[iarray]<0) { dyr[i]=dx; vwarn("'dyrcv' element %li (%f) is less than zero, changing it to %f'",iarray,dyr[iarray],dy); } } for (iarray=0;iarray<Ndz;iarray++) { if (dzr[iarray]<0) { dzr[iarray]=dz; vwarn("'dzrcv' element %li (%f) is less than zero, changing it to %f'",iarray,dzr[iarray],dz); } } for (iarray=0;iarray<Ndx;iarray++){ if (dxr[iarray]==0 && dzr[iarray]==0) { xrcv2[iarray]=xrcv1[iarray]; dxr[iarray]=1.; vwarn("'dxrcv' element %li & 'dzrcv' element 1 are both 0.",iarray+1); vmess("Placing 1 receiver at (%li,%li)",xrcv1[iarray],zrcv1[iarray]); } } for (iarray=0;iarray<Ndx;iarray++){ if (xrcv1[iarray]==xrcv2[iarray] && dxr[iarray]!=0) { dxr[iarray]=0.; vwarn("Linear array %li: 'xrcv1'='xrcv2' and 'dxrcv' is not 0. Setting 'dxrcv'=0",iarray+1); } } for (iarray=0;iarray<Ndx;iarray++){ if (yrcv1[iarray]==yrcv2[iarray] && dyr[iarray]!=0) { dyr[iarray]=0.; vwarn("Linear array %li: 'yrcv1'='yrcv2' and 'dyrcv' is not 0. Setting 'dyrcv'=0",iarray+1); } } for (iarray=0;iarray<Ndx;iarray++){ if (zrcv1[iarray]==zrcv2[iarray] && dzr[iarray]!=0.){ dzr[iarray]=0.; vwarn("Linear array %li: 'zrcv1'='zrcv2' and 'dzrcv' is not 0. Setting 'dzrcv'=0",iarray+1); } } /* Calculate Number of Receivers */ nrcv = 0; nlxrcv=(long *)malloc(Nx1*sizeof(long)); nlyrcv=(long *)malloc(Nx1*sizeof(long)); for (iarray=0; iarray<Nx1; iarray++) { xrange = (xrcv2[iarray]-xrcv1[iarray]); yrange = (yrcv2[iarray]-yrcv1[iarray]); zrange = (zrcv2[iarray]-zrcv1[iarray]); if (dxr[iarray] != 0.0 && dyr[iarray] != 0.0) { nlxrcv[iarray] = NINT(fabs(xrange/dxr[iarray]))+1; nlyrcv[iarray] = NINT(fabs(yrange/dyr[iarray]))+1; } else if (dxr[iarray] != 0.0) { nlxrcv[iarray] = NINT(fabs(xrange/dxr[iarray]))+1; nlyrcv[iarray] = 1; } else if (dyr[iarray] != 0.0) { nlxrcv[iarray] = 1; nlyrcv[iarray] = NINT(fabs(yrange/dyr[iarray]))+1; } else { if (dzr[iarray] == 0) { verr("For receiver array %li: receiver distance dzrcv is not given", iarray); } nlxrcv[iarray] = NINT(fabs(zrange/dzr[iarray]))+1; nlyrcv[iarray] = NINT(fabs(zrange/dzr[iarray]))+1; } nrcv+=nlyrcv[iarray]*nlxrcv[iarray]; } /* Calculate Number of Receivers */ if (verbose) vmess("Total number of linear array receivers: %li",nrcv); if (!nrcv) { free(xrcv1); free(xrcv2); free(yrcv1); free(yrcv2); free(zrcv1); free(zrcv2); free(dxr); free(dyr); free(dzr); free(nlxrcv); free(nlyrcv); } rec->max_nrec+=nrcv; } else { nrcv=0; } /* allocate the receiver arrays */ /* Total Number of Receivers */ if (verbose) vmess("Total number of receivers: %li",rec->max_nrec); /* Allocate Arrays */ rec->x = (long *)calloc(rec->max_nrec,sizeof(long)); rec->y = (long *)calloc(rec->max_nrec,sizeof(long)); rec->z = (long *)calloc(rec->max_nrec,sizeof(long)); rec->xr = (float *)calloc(rec->max_nrec,sizeof(float)); rec->yr = (float *)calloc(rec->max_nrec,sizeof(float)); rec->zr = (float *)calloc(rec->max_nrec,sizeof(float)); /* read in the receiver postions */ nrec=0; /* Receiver Array */ if (nxrcv != 0 && nyrcv != 0) { /* receiver array is defined */ xrcva = (float *)malloc(nxrcv*sizeof(float)); yrcva = (float *)malloc(nxrcv*sizeof(float)); zrcva = (float *)malloc(nxrcv*sizeof(float)); getparfloat("xrcva", xrcva); getparfloat("yrcva", yrcva); getparfloat("zrcva", zrcva); for (iy=0; iy<nyrcv; iy++) { for (ix=0; ix<nxrcv; ix++) { rec->xr[nrec+iy*nxrcv+ix] = xrcva[ix]-sub_x0; rec->yr[nrec+iy*nxrcv+ix] = yrcva[iy]-sub_y0; rec->zr[nrec+iy*nxrcv+ix] = zrcva[ix]-sub_z0; rec->x[nrec+iy*nxrcv+ix] = NINT((xrcva[ix]-sub_x0)/dx); rec->y[nrec+iy*nxrcv+ix] = NINT((yrcva[iy]-sub_y0)/dy); rec->z[nrec+iy*nxrcv+ix] = NINT((zrcva[ix]-sub_z0)/dz); if (verbose>4) fprintf(stderr,"Receiver Array: xrcv[%li]=%f yrcv[%li]=%f zrcv=%f\n", ix, rec->xr[nrec+ix]+sub_x0, iy, rec->yr[nrec+ix]+sub_y0, rec->zr[nrec+ix]+sub_z0); } } free(xrcva); free(yrcva); free(zrcva); nrec += nyrcv*nxrcv; } /* Linear Receiver Arrays */ if (nrcv!=0) { xrcv1 = (float *)malloc(Nx1*sizeof(float)); xrcv2 = (float *)malloc(Nx1*sizeof(float)); yrcv1 = (float *)malloc(Nx1*sizeof(float)); yrcv2 = (float *)malloc(Nx1*sizeof(float)); zrcv1 = (float *)malloc(Nx1*sizeof(float)); zrcv2 = (float *)malloc(Nx1*sizeof(float)); if(!getparfloat("xrcv1", xrcv1)) xrcv1[0]=sub_x0; if(!getparfloat("xrcv2", xrcv2)) xrcv2[0]=(nx-1)*dx+sub_x0; if(!getparfloat("yrcv1", yrcv1)) yrcv1[0]=sub_y0; if(!getparfloat("yrcv2", yrcv2)) yrcv2[0]=(ny-1)*dy+sub_y0; if(!getparfloat("zrcv1", zrcv1)) zrcv1[0]=sub_z0; if(!getparfloat("zrcv2", zrcv2)) zrcv2[0]=zrcv1[0]; Ndx = countparval("dxrcv"); Ndy = countparval("dyrcv"); Ndz = countparval("dzrcv"); dxr = (float *)malloc(Nx1*sizeof(float)); dyr = (float *)malloc(Nx1*sizeof(float)); dzr = (float *)malloc(Nx1*sizeof(float)); if(!getparfloat("dxrcv", dxr)) dxr[0]=dx; if(!getparfloat("dyrcv", dyr)) dyr[0]=dy; if(!getparfloat("dzrcv", dzr)) dzr[0]=0.0; if ( (Ndx<=1) && (Ndy<=1) && (Ndz==0) ){ /* default values are set */ for (i=1; i<Nx1; i++) { dxr[i] = dxr[0]; dyr[i] = dyr[0]; dzr[i] = dzr[0]; } Ndx=1; Ndy=1; } else if ( (Ndx<=1) && (Ndy==0) && (Ndz==0) ){ /* default values are set */ for (i=1; i<Nx1; i++) { dxr[i] = dxr[0]; dyr[i] = dyr[0]; dzr[i] = dzr[0]; } Ndx=1; } else if ( (Ndy<=1) && (Ndx==0) && (Ndz==0) ){ /* default values are set */ for (i=1; i<Nx1; i++) { dxr[i] = dxr[0]; dyr[i] = dyr[0]; dzr[i] = dzr[0]; } Ndy=1; } else if ( (Ndz==1) && (Ndy==0) && (Ndx==0) ){ /* default values are set */ for (i=1; i<Nx1; i++) { dxr[i] = dxr[0]; dyr[i] = dyr[0]; dzr[i] = dzr[0]; } Ndz=1; } else { /* make sure that each array has dzrcv or dxrcv defined for each line or receivers */ if (Ndx>1) assert(Ndx==Nx1); if (Ndy>1) assert(Ndy==Ny1); if (Ndz>1) assert(Ndz==Nx1); } /* check if receiver arrays fit into model */ for (iarray=0; iarray<Nx1; iarray++) { xrcv1[iarray] = MAX(sub_x0, xrcv1[iarray]); xrcv1[iarray] = MIN(sub_x0+nx*dx,xrcv1[iarray]); xrcv2[iarray] = MAX(sub_x0, xrcv2[iarray]); xrcv2[iarray] = MIN(sub_x0+nx*dx,xrcv2[iarray]); yrcv1[iarray] = MAX(sub_y0, yrcv1[iarray]); yrcv1[iarray] = MIN(sub_y0+ny*dy,yrcv1[iarray]); yrcv2[iarray] = MAX(sub_y0, yrcv2[iarray]); yrcv2[iarray] = MIN(sub_y0+ny*dy,yrcv2[iarray]); zrcv1[iarray] = MAX(sub_z0, zrcv1[iarray]); zrcv1[iarray] = MIN(sub_z0+nz*dz,zrcv1[iarray]); zrcv2[iarray] = MAX(sub_z0, zrcv2[iarray]); zrcv2[iarray] = MIN(sub_z0+nz*dz,zrcv2[iarray]); } /* calculate receiver array and store into rec->x,y,z */ for (iarray=0; iarray<Nx1; iarray++) { xrange = (xrcv2[iarray]-xrcv1[iarray]); yrange = (yrcv2[iarray]-yrcv1[iarray]); zrange = (zrcv2[iarray]-zrcv1[iarray]); if (dxr[iarray] != 0.0) { nrcv = nlyrcv[iarray]*nlxrcv[iarray]; dxrcv = dxr[iarray]; dyrcv = yrange/(nlyrcv[iarray]-1); dzrcv = zrange/(nlxrcv[iarray]-1); if (dyrcv != dyr[iarray]) { vwarn("For receiver array %li: calculated dyrcv=%f given=%f", iarray, dyrcv, dyr[iarray]); vwarn("The calculated receiver distance %f is used", dyrcv); } if (dzrcv != dzr[iarray]) { vwarn("For receiver array %li: calculated dzrcv=%f given=%f", iarray, dzrcv, dzr[iarray]); vwarn("The calculated receiver distance %f is used", dzrcv); } } else if (dyr[iarray] != 0.0) { nrcv = nlyrcv[iarray]*nlxrcv[iarray]; dxrcv = xrange/(nlxrcv[iarray]-1); dyrcv = dyr[iarray]; dzrcv = zrange/(nlxrcv[iarray]-1); if (dxrcv != dxr[iarray]) { vwarn("For receiver array %li: calculated dxrcv=%f given=%f", iarray, dxrcv, dxr[iarray]); vwarn("The calculated receiver distance %f is used", dxrcv); } if (dzrcv != dzr[iarray]) { vwarn("For receiver array %li: calculated dzrcv=%f given=%f", iarray, dzrcv, dzr[iarray]); vwarn("The calculated receiver distance %f is used", dzrcv); } } else { if (dzr[iarray] == 0) { verr("For receiver array %li: receiver distance dzrcv is not given", iarray); } nrcv = nlyrcv[iarray]*nlxrcv[iarray]; dxrcv = xrange/(nrcv-1); dyrcv = yrange/(nrcv-1); dzrcv = dzr[iarray]; if (dxrcv != dxr[iarray]) { vwarn("For receiver array %li: calculated dxrcv=%f given=%f", iarray, dxrcv, dxr[iarray]); vwarn("The calculated receiver distance %f is used", dxrcv); } if (dyrcv != dyr[iarray]) { vwarn("For receiver array %li: calculated dyrcv=%f given=%f", iarray, dyrcv, dyr[iarray]); vwarn("The calculated receiver distance %f is used", dyrcv); } } // calculate coordinates for (iy=0; iy<nlyrcv[iarray]; iy++) { for (ix=0; ix<nlxrcv[iarray]; ix++) { rec->xr[nrec]=xrcv1[iarray]-sub_x0+ix*dxrcv; rec->yr[nrec]=yrcv1[iarray]-sub_y0+iy*dyrcv; rec->zr[nrec]=zrcv1[iarray]-sub_z0+ix*dzrcv; rec->x[nrec]=NINT((rec->xr[nrec])/dx); rec->y[nrec]=NINT((rec->yr[nrec])/dy); rec->z[nrec]=NINT((rec->zr[nrec])/dz); nrec++; } } } free(xrcv1); free(xrcv2); free(yrcv1); free(yrcv2); free(zrcv1); free(zrcv2); free(dxr); free(dyr); free(dzr); free(nlxrcv); free(nlyrcv); } rec->n=rec->max_nrec; return 0; }
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; }