void unwrap_phase(int n, float w, float *phase)
/************************************************************************
unwrap_phase - unwrap the phase
*************************************************************************
Input:
n number of samples
w unwrapping flag; returns an error if w=0
phase array[n] of input phase values
Output:
phase array[n] of output phase values
*************************************************************************
Notes:
The phase is assumed to be continuously increasing. The strategy is
to look at the change in phase (dphase) with each time step. If it is larger
than PI/w, then use the previous value of dphase. No attempt is
made at smoothing the dphase curve.
*************************************************************************
Author: John Stockwell, CWP, 1994
************************************************************************/
{
int i;
float pibyw=0.0;
float *dphase;
float *temp;
/* prevent division by zero in PI/w */
if (w==0) err("wrapping parameter is zero");
else pibyw = PI/w;
/* allocate space */
dphase = ealloc1float(n);
temp = ealloc1float(n);
/* initialize */
temp[0]=phase[0];
dphase[0]=0.0;
/* compute unwrapped phase at each time step */
for (i = 1; i < n; ++i) {
/* compute jump in phase */
dphase[i] = ABS(phase[i] - phase[i-1]);
/* if dphase >= PI/w, use previous dphase value */
if (ABS(dphase[i] - dphase[i-1]) >= pibyw )
dphase[i] = dphase[i-1];
/* sum up values in temporary vector */
temp[i] = temp[i-1] + dphase[i];
}
/* assign values of temporary vector to phase[i] */
for (i=0; i<n; ++i) phase[i] = temp[i];
/* free space */
free1float(temp);
free1float(dphase);
}
void integ(float **mig,int nz,float dz,int nx,int m,float **migi)
/* integration of a two-dimensional array
input:
mig[nx][nz] two-dimensional array
output:
migi[nx][nz+2*m] integrated array
*/
{
int nfft, nw, ix, iz, iw;
float *amp, dw, *rt;
complex *ct;
/* Set up FFT parameters */
nfft = npfaro(nz+m, 2 * (nz+m));
if (nfft >= SU_NFLTS || nfft >= 720720)
err("Padded nt=%d -- too big", nfft);
nw = nfft/2 + 1;
dw = 2.0*PI/(nfft*dz);
amp = ealloc1float(nw);
for(iw=1; iw<nw; ++iw)
amp[iw] = 0.5/(nfft*(1-cos(iw*dw*dz)));
amp[0] = amp[1];
/* Allocate fft arrays */
rt = ealloc1float(nfft);
ct = ealloc1complex(nw);
for(ix=0; ix<nx; ++ix) {
memcpy(rt, mig[ix], nz*FSIZE);
memset((void *) (rt + nz), 0, (nfft-nz)*FSIZE);
pfarc(1, nfft, rt, ct);
/* Integrate traces */
for(iw=0; iw<nw; ++iw){
ct[iw].i = ct[iw].i*amp[iw];
ct[iw].r = ct[iw].r*amp[iw];
}
pfacr(-1, nfft, ct, rt);
for (iz=0; iz<m; ++iz) migi[ix][iz] = rt[nfft-m+iz];
for (iz=0; iz<nz+m; ++iz) migi[ix][iz+m] = rt[iz];
}
free1float(amp);
free1float(rt);
free1complex(ct);
}
/* Break up reflectors by duplicating interior (x,z) points */
void breakReflectors (int *nr, float **ar,
int **nu, float ***xu, float ***zu)
{
int nri,nro,*nui,*nuo,ir,jr,iu;
float *ari,*aro,**xui,**zui,**xuo,**zuo;
/* input reflectors */
nri = *nr;
ari = *ar;
nui = *nu;
xui = *xu;
zui = *zu;
/* number of output reflectors */
for (ir=0,nro=0; ir<nri; ++ir)
nro += nui[ir]-1;
/* make output reflectors and free space for input reflectors */
aro = ealloc1float(nro);
nuo = ealloc1int(nro);
xuo = ealloc1(nro,sizeof(float*));
zuo = ealloc1(nro,sizeof(float*));
for (ir=0,jr=0; ir<nri; ++ir) {
for (iu=0; iu<nui[ir]-1; ++iu,++jr) {
aro[jr] = ari[ir];
nuo[jr] = 2;
xuo[jr] = ealloc1float(2);
zuo[jr] = ealloc1float(2);
xuo[jr][0] = xui[ir][iu];
zuo[jr][0] = zui[ir][iu];
xuo[jr][1] = xui[ir][iu+1];
zuo[jr][1] = zui[ir][iu+1];
}
free1float(xui[ir]);
free1float(zui[ir]);
}
free1float(ari);
free1int(nui);
free1(xui);
free1(zui);
/* output reflectors */
*nr = nro;
*ar = aro;
*nu = nuo;
*xu = xuo;
*zu = zuo;
}
void makericker (float fpeak, float dt, Wavelet **w)
/*****************************************************************************
Make Ricker wavelet
******************************************************************************
Input:
fpeak peak frequency of wavelet
dt time sampling interval
Output:
w Ricker wavelet
*****************************************************************************/
{
int iw,lw,it,jt;
float t,x,*wv;
iw = -(1+1.0/(fpeak*dt));
lw = 1-2*iw;
wv = ealloc1float(lw);
for (it=iw,jt=0,t=it*dt; jt<lw; ++it,++jt,t+=dt) {
x = PI*fpeak*t;
x = x*x;
wv[jt] = exp(-x)*(1.0-2.0*x);
}
*w = ealloc1(1,sizeof(Wavelet));
(*w)->lw = lw;
(*w)->iw = iw;
(*w)->wv = wv;
}
static void mkvrms (int ndmo, float *tdmo, float *vdmo,
int nt, float dt, float ft, float *vrms)
/*****************************************************************************
make uniformly sampled vrms(t) for DMO
******************************************************************************
Input:
ndmo number of tdmo,vdmo pairs
tdmo array[ndmo] of times
vdmo array[ndmo] of rms velocities
nt number of time samples
dt time sampling interval
ft first time sample
Output:
vrms array[nt] of rms velocities
******************************************************************************
Author: Dave Hale, Colorado School of Mines, 10/03/91
*****************************************************************************/
{
int it;
float t,(*vdmod)[4];
vdmod = (float(*)[4])ealloc1float(ndmo*4);
cmonot(ndmo,tdmo,vdmo,vdmod);
for (it=0,t=ft; it<nt; ++it,t+=dt)
intcub(0,ndmo,tdmo,vdmod,1,&t,&vrms[it]);
free1float((float*)vdmod);
}
void twindow(int nt, int wtime, float *data)
/************************************************************
twindow - simple time gating
*************************************************************
Input:
nt number of time samples
wtime = n*dt where n are integer ex=1,2,3,4,5,...
wtime=3 as default
used for Frequency Weighted and Thin-bed attributes
*************************************************************
Author: UGM (Geophysics Students): Agung Wiyono, 2005
************************************************************/
{
float val;
float *temp;
int i;
float sum;
int nwin;
nwin=2*wtime+1;
temp = ealloc1float(nt);
sum=0.0;
for (i = 0; i< wtime+1; ++i) {
val = data[i];
sum +=val;
}
/* weighted */
temp[0] = sum/nwin;
/* dt<wtime */
for (i = 1; i < wtime; ++i) {
val = data[i+wtime];
sum+=val;
++nwin;
temp[i] = sum/nwin;
}
/*wtime<dt<dt-wtime */
for (i = wtime ; i < nt-wtime; ++i) {
val = data[i+wtime];
sum += val;
val = data[i-wtime];
sum -=val;
temp[i] = sum/nwin;
}
/*dt-wtime<dt*/
for (i = nt - wtime; i < nt; ++i) {
val = data[i-wtime];
sum -= val;
--nwin;
temp[i] = sum/nwin;
}
for (i=0; i<nt; ++i) data[i] = temp[i];
/* Memori free */
free1float(temp);
}
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());
}
void tabtrcoefs(int ninf, float *rho, float *v, float **theta,
float *dip, float *trcoefs)
/*****************************************************************************
table transmission coefficients
******************************************************************************
Input:
ninf x coordinate of source (must be within x samples)
xxxx
Output:
trcoefs array[1..ninf] containing transmission coefficients
******************************************************************************
Notes:
The parameters are exactly the same as in the main program.
This is a subroutine so that the temporary arrays may be disposed
of after exit. This routine is only called once.
******************************************************************************
Author: Brian Sumner, Colorado School of Mines, 1985
******************************************************************************/
{
/**
* Local variables:
* TEMP, TMP - temporary arrays
* I, J - loop variables
* T1, T2 - temporaries
* R, P - more temporaries
**/
int i,j;
float t1, t2, r, p, *temp, **tmp;
temp = ealloc1float(ninf+1);
tmp = ealloc2float(ninf+1, ninf+1);
for (i = 0; i <= ninf; ++i) temp[i] = rho[i]*v[i];
for (j = 1; j <= ninf; ++j) {
for (i = 1; i < j; ++i) {
t1 = temp[i]*cos(theta[j][i-1]+dip[i]);
t2 = temp[i-1]*cos(theta[j][i]+dip[i]);
r = (t1 - t2)/(t1 + t2);
tmp[j][i] = 1.0 - r*r;
}
}
for (j = 1; j <= ninf; ++j) {
t1 = temp[j];
t2 = temp[j-1];
p = (t1 - t2)/(t1 + t2);
for (i = 1; i < j; ++i) p *= tmp[j][i];
trcoefs[j] = p;
}
/* free space */
free1float(temp);
free2float(tmp);
}
void remove_fb(float *yp,float *ym,int n,short *scaler,short *shft)
/* Find Scale and timeshift
Yp = data trace
Ym = wavelet
F=min(Yp(x) - Ym(x)*a)^2 is a function to minimize for scaler
find shift first with xcorrelation then
solve for a - scaler
*/
{
#define RAMPR 5
void find_p(float *ym,float *yp,float *a,int *b,int n);
int it,ir;
float a=1.0;
int b=0;
int ramps;
float *a_ramp;
ramps=NINT(n-n/RAMPR);
find_p(ym,yp,&a,&b,n);
a_ramp = ealloc1float(n);
for(it=0;it<ramps;it++)
a_ramp[it]=1.0;
for(it=ramps,ir=0;it<n;it++,ir++) {
a_ramp[it]=1.0-(float)ir/(float)(n-ramps-1);
}
if (b<0) {
for(it=0;it<n+b;it++)
yp[it-b] -=ym[it]*a*a_ramp[it-b];
} else {
for(it=0;it<n-b;it++)
yp[it] -=ym[it-b]*a*a_ramp[it+b];
}
*scaler = NINT((1.0-a)*100.0);
*shft = b;
free1float(a_ramp);
}
void find_p(float *ym,float *yp,float *a,int *b,int n)
{
#define NP 1
float *y,**x;
int n_s;
int k;
float *res;
int jpvt[NP];
float qraux[NP];
float work[NP];
x = ealloc2float(n,1);
y = ealloc1float(n);
res = ealloc1float(n);
memcpy((void *) &x[0][0], (const void *) &ym[0], n*FSIZE);
memset((void *) y, (int) '\0', n*FSIZE);
/* Solve for shift */
xcor (n,0,ym,n,0,yp,n,-n/2,y);
/* pick the maximum */
*b = -max_index(n,y,1)+n/2;
n_s = n-abs(*b);
if (*b < 0) {
memcpy((void *) &x[0][0], (const void *) &ym[*b], n_s*FSIZE);
} else {
memcpy((void *) &x[0][*b], (const void *) &ym[0], n_s*FSIZE);
}
/* Solve for scaler */
sqrst(x, n_s, 1,yp,0.0,a,res,&k,&jpvt[0],&qraux[0],&work[0]);
free2float(x);
free1float(res);
free1float(y);
}
int main( int argc, char *argv[] )
{
int n1; /* number of x y values */
int stinc; /* x increment */
int f; /* filter length */
int m; /* filter method flag */
float *x; /* array of x index values */
float *y; /* array of y values */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
MUSTGETPARINT("n1",&n1);
if( !getparint("stinc",&stinc)) stinc=1;
if( !getparint("f",&f)) f=5;
if( !getparint("m",&m)) m=1;
/* allocate arrays */
x = ealloc1float(n1);
y = ealloc1float(n1);
/* Read data into the arrays */
{ int i;
for(i=0;i<n1;i++) {
fscanf(stdin," %f %f\n",&x[i],&y[i]);
}
}
/* smooth */
sm_st(x,y,n1,f,stinc,m);
/* Write out */
{ int i;
for(i=0;i<n1;i++) {
fprintf(stdout," %10.3f %10.3f\n",x[i],y[i]);
}
}
free1float(x);
free1float(y);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
int nt; /* number of samples on input */
int ntout; /* number of samples on output */
int it; /* counter */
int istart; /* beginning sample */
int izero; /* - istart */
int norm; /* user defined normalization value */
int sym; /* symmetric plot? */
float scale; /* scale factor computed from norm */
float *temp=NULL; /* temporary array */
float dt; /* time sampling interval (sec) */
/* hook up getpar */
initargs(argc, argv);
requestdoc(1);
/* get information from the first header */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
dt = tr.dt/1000000.0;
/* get parameters */
if (!getparint("ntout",&ntout)) ntout=101;
if (!getparint("norm",&norm)) norm = 1;
if (!getparint("sym",&sym)) sym = 1;
checkpars();
/* allocate workspace */
temp = ealloc1float(ntout);
/* index of first sample */
if (sym == 0) istart = 0;
else istart = -(ntout-1)/2;
/* index of sample at time zero */
izero = -istart;
/* loop over traces */
do {
xcor(nt,0,tr.data,nt,0,tr.data,ntout,istart,temp);
if (norm) {
scale = 1.0/(temp[izero]==0.0?1.0:temp[izero]);
for (it=0; it<ntout; ++it) temp[it] *= scale;
}
memcpy((void *) tr.data, (const void *) temp, ntout*FSIZE);
tr.ns = ntout;
tr.f1 = -dt*ntout/2.0;
tr.delrt = 0;
puttr(&tr);
} while(gettr(&tr));
return(CWP_Exit());
}
int main( int argc, char *argv[] )
{
/* 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)
{
char *outpar; /* name of file holding output parfile */
FILE *outparfp; /* ... its file pointer */
int n1; /* number of floats per line */
size_t n1read; /* number of items read */
size_t n2 = 0; /* number of lines in input file */
float *z; /* binary floats */
/* Hook up getpar */
initargs(argc, argv);
requestdoc(1);
/* Get parameters and do set up */
if (!getparstring("outpar", &outpar)) outpar = "/dev/tty" ;
outparfp = efopen(outpar, "w");
MUSTGETPARINT("n1",&n1);
z = ealloc1float(n1);
/* Loop over data converting to ascii */
while ((n1read = efread(z, FSIZE, n1, stdin))) {
register int i1;
if (n1read != n1)
err("out of data in forming line #%d", n2+1);
for (i1 = 0; i1 < n1; ++i1)
/* z2xyz.c:70: warning: format ‘%d’ expects type ‘int’, but argument 2 has type ‘size_t’ */
/* printf("%d %d %11.4e \n",n2,i1,z[i1]); */
#if __WORDSIZE == 64
printf("%lu %d %11.4e \n",n2,i1,z[i1]);
#else
printf("%u %d %11.4e \n",n2,i1,z[i1]);
#endif
++n2;
}
/* Make par file */
/* z2xyz.c:76: warning: format ‘%d’ expects type ‘int’, but argument 3 has type ‘size_t’ */
/* fprintf(outparfp, "n2=%d\n", n2); */
#if __WORDSIZE == 64
fprintf(outparfp, "n2=%lu\n", n2);
#else
fprintf(outparfp, "n2=%u\n", n2);
#endif
return(CWP_Exit());
}
int
main (int argc, char **argv)
{
int n1,n2,i2;
float f1,f2,d1,d2,*x;
char *label2="Trace",label[256];
FILE *infp=stdin,*outfp=stdout;
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(0);
/* get optional parameters */
if (!getparint("n1",&n1)) {
if (efseeko(infp,(off_t) 0,SEEK_END)==-1)
err("input file size is unknown; specify n1!\n");
if ((n1=((int) (eftello(infp)/((off_t) sizeof(float)))))<=0)
err("input file size is unknown; specify n1!\n");
efseeko(infp,(off_t) 0,SEEK_SET);
}
if (!getparfloat("d1",&d1)) d1 = 1.0;
if (!getparfloat("f1",&f1)) f1 = d1;
if (!getparint("n2",&n2)) n2 = -1;
if (!getparfloat("d2",&d2)) d2 = 1.0;
if (!getparfloat("f2",&f2)) f2 = d2;
getparstring("label2",&label2);
/* allocate space */
x = ealloc1float(n1);
/* loop over 2nd dimension */
for (i2=0; i2<n2 || n2<0; i2++) {
/* read input array, watching for end of file */
if (efread(x,sizeof(float),n1,infp)!=n1) break;
/* make plot label */
sprintf(label,"%s %0.4g",label2,f2+i2*d2);
/* plot the array */
prp1d(outfp,label,n1,d1,f1,x);
}
return(CWP_Exit());
}
void differentiate(int n, float h, float *f)
/************************************************************************
differentiate - compute the 1st derivative of a function f[]
************************************************************************
Input:
n number of samples
h sample rate
f array[n] of input values
Output:
f array[n], the derivative of f
************************************************************************
Notes:
This is a simple 2 point centered-difference differentiator.
The derivatives at the endpoints are computed via 2 point leading and
lagging differences.
************************************************************************
Author: John Stockwell, CWP, 1994
************************************************************************/
{
int i;
float *temp;
float h2=2*h;
/* allocate space in temporary vector */
temp = ealloc1float(n);
/* do first as a leading difference */
temp[0] = (f[1] - f[0])/h;
/* do the middle values as a centered difference */
for (i=1; i<n-1; ++i) temp[i] = (f[i+1] - f[i-1])/h2;
/* do last value as a lagging difference */
temp[n-1] = (f[n-1] - f[n-2])/h;
for (i=0 ; i < n ; ++i) f[i] = temp[i];
free1float(temp);
}
static void makezt (int nz, float dz, float fz, float v[],
int nt, float dt, float ft, float z[])
/************************************************************************
makezt - compute z(t) from v(z)
*************************************************************************
Input:
nz number of z values (output)
dz depth sampling interval (output)
fz first depth value (output)
v[] array of velocities as a function of time t
nt number of time samples
dt time sampling interval
ft first time sample
Output:
z[] array of z values as a function of t
*************************************************************************
Author: CWP: based on maketz by Dave Hale (c. 1992)
*************************************************************************/
{
int iz; /* counter */
float vfz; /* velocity at the first depth sample */
float vlz; /* velocity at the last depth sample */
float *t=NULL; /* array of time values as a function of z */
/* allocate space */
t = ealloc1float(nz);
/* calculate t(z) from v(z) */
t[0] = 2.0*fz/v[0];
for (iz=1; iz<nz; ++iz)
t[iz] = t[iz-1]+2.0*dz/v[iz-1];
vfz = v[0];
vlz = v[nz-1];
/* compute z(t) from t(z) */
tzzt(nz,dz,fz,t,vfz,vlz,nt,dt,ft,z);
free1float(t);
}
void bandpass(float *data, int nt, int nfft, int nfreq,
float *filterj, float *ftracej)
{
float *rt;
complex *ct;
int i;
rt = ealloc1float(nfft);
ct = ealloc1complex(nfreq);
/* Load trace into rt (zero-padded) */
memcpy((char*) rt, (char*) data, nt*FSIZE);
bzero(rt + nt, (nfft-nt)*FSIZE);
/* FFT, filter, inverse FFT */
pfarc(1, nfft, rt, ct);
for (i = 0; i < nfreq; ++i) ct[i] = crmul(ct[i], filterj[i]);
pfacr(-1, nfft, ct, rt);
/* Load traces back in, recall filter had nfft factor */
for (i = 0; i < nt; ++i) ftracej[i] = rt[i]; /* ftracej = rt ?? */
free(rt);
free(ct);
}
void do_smooth(float *data, int nt, int isl) /********************************************************************** do_smooth - smooth data in a window of length isl samples ********************************************************************** Input: data[] array of floats of size nt nt size of array isl integerized window length Output: returns smoothed data. ********************************************************************** Author: Nils Maercklin, GeoForschungsZentrum (GFZ) Potsdam, Germany, 2001. E-mail: [email protected] **********************************************************************/ { register int it,jt; float *tmpdata, sval; tmpdata=ealloc1float(nt); for (it=0;it<nt;it++) { sval=0.0; if ( (it >= isl/2) && (it < nt-isl/2) ) { for (jt=it-isl/2;jt<it+isl/2;jt++) { sval += data[jt]; } tmpdata[it] = sval / (float) isl; } else { tmpdata[it] = data[it]; } } memcpy((void *) data, (const void *) tmpdata, nt*FSIZE); free1float(tmpdata); }
void do_smooth(float *data, int nt, int isl)
{
int it,jt;
float *tmpdata, sval;
tmpdata=ealloc1float(nt);
for (it=0;it<nt;it++) {
sval=0.0;
if ( (it >= isl/2) && (it < nt-isl/2) ) {
for (jt=it-isl/2;jt<it+isl/2;jt++) {
sval += data[jt];
}
tmpdata[it] = sval / (float) isl;
}
else {
tmpdata[it] = 0.0;
}
}
for (it=0;it<nt;it++) {
data[it] = tmpdata[it];
}
free1float(tmpdata);
}
int
main(int argc, char **argv)
{
register float *rt; /* real trace */
register float *mt; /* magnitude trace */
register float *ct; /* resampled centroid trace */
int nt; /* number of points on input trace */
int verbose; /* flag to get advisory messages */
float dt; /* sampling interval in secs */
float invdt; /* inverse dt */
float hdt; /* half dt */
cwp_Bool inflect=cwp_false; /* inflection point flag */
cwp_Bool zero_cross=cwp_false; /* zero-crossing flag */
cwp_Bool max_passed=cwp_false; /* maximum value passed flag */
float *time; /* array of trace sample time values */
float sum_amp; /* sum of amplitudes in lobe */
float t_cen; /* centroid about amplitude axis */
int isamp; /* t_cen time sample number */
float a_cen; /* centroid about time axis */
float a_mom; /* moment about time axis */
float t_mom; /* moment about amplitude axis */
float a_height; /* height of region for moment calc */
float t_width; /* width of region for moment calc */
int first; /* number of first sample in lobe */
int last; /* number of last sample in lobe */
int prev; /* number of past sample in amp moment */
int small; /* sample number of current smaller mag */
int nvals; /* number of samples in current lobe */
int nvals_min; /* minimum samples in lobe for inclusion*/
int i,k; /* counter indices */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
if (!getparint("verbose", &verbose)) verbose=1;
if (!getparint("nvals_min", &nvals_min)) nvals_min = 1;
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
/* dt is used only to set output header value d1 */
if (!getparfloat("dt", &dt)) dt = ((double) tr.dt)/1000000.0;
if (!dt) {
dt = .004;
if (verbose) warn("dt not set, assumed to be .004");
}
invdt = 1.0 / dt;
hdt = 0.5 * dt;
/* Allocate space */
rt = ealloc1float(nt);
ct = ealloc1float(nt);
mt = ealloc1float(nt);
time = ealloc1float(nt);
/* create an array of times */
for (i = 0; i < nt; ++i) {
time[i] = (float)(i + 1) * dt;
}
/* Main loop over traces */
do {
register int i;
/* Load trace into rt and zero ct */
memcpy((void *) rt, (const void *) tr.data, nt*FSIZE);
memset((void *) ct, 0, nt*FSIZE);
first = 0;
mt[0] = fabs(rt[0]);
sum_amp = rt[0];
t_mom = time[0] * mt[0];
for (i = 1; i < nt; ++i) {
mt[i] = fabs(rt[i]);
/* test for zero-crossing or inflection point */
if(rt[i] * rt[i-1] > (float)0) {
if(mt[i] > mt[i-1]) {
if(max_passed) inflect = cwp_true;
} else {
max_passed = cwp_true;
}
} else {
zero_cross = cwp_true;
}
/* if a zero-crossing or inflection point is not */
/* encountered on the current trace sample, */
/* accumulate the time moment */
/* and sum of the lobe amplitude */
if(!zero_cross && !inflect) {
sum_amp = sum_amp + rt[i];
t_mom = t_mom + (time[i] * mt[i]);
} else {
/* otherwise a zero-crossing or inflection has */
/* occured, so stop and determine amplitude */
/* centroid and store results as a centroid */
/* sample for the current lobe */
/* determine the amplitude centroid */
last = i - 1;
/* if inflection point has been found divide it */
/* between the calcs for this lobe and the next */
if (inflect) {
last = i;
rt[last] = rt[last] * 0.5;
mt[last] = fabs(rt[last]);
sum_amp = sum_amp + rt[last];
t_mom = t_mom + (time[last] * mt[last]);
}
nvals = last - first + 1;
if(nvals == 1) {
/* check to see if lobe is big enough */
/* to be included */
if(nvals >= nvals_min) {
ct[i] = rt[i] * 0.5;
}
first = i;
inflect = cwp_false;
max_passed = cwp_false;
zero_cross = cwp_false;
sum_amp = rt[i];
t_mom = time[i] * mt[i];
} else {
a_height = mt[first];
if(mt[first] > mt[last]) {
a_height = mt[last];
}
t_width = time[last] - time[first] + dt;
a_mom = a_height * 0.5;
a_cen = t_width * a_height * a_mom;
small = first;
if (mt[first] > mt[last]) small = last;
for (k = 1; k < nvals; k ++) {
prev = small;
if (prev == first) first = first + 1;
else last = last - 1;
small = first;
if(mt[first] > mt[last]) small = last;
a_height = rt[small] - rt[prev];
a_mom = rt[prev] + (a_height * 0.5);
t_width = t_width - dt;
a_cen = a_cen + a_mom*t_width*a_height;
}
if(sum_amp == 0.0) {
warn("i = %d, sum_amp = %f,divide by zero !",
i,sum_amp);
}
a_cen = a_cen / (sum_amp * dt);
/* determine the time centroid */
t_cen = t_mom / fabs(sum_amp);
/* start accumulating amplitude sum */
/* and time moment for next lobe */
sum_amp = rt[i];
t_mom = time[i] * mt[i];
/* set sample corresponding to t_cen */
/* to amplitude a_cen */
isamp = (int) ((t_cen * invdt) + hdt);
/* check to see if lobe is big enough */
/* to be included */
if(nvals >= nvals_min) {
ct[isamp] = a_cen;
}
first = i;
inflect = cwp_false;
max_passed = cwp_false;
zero_cross = cwp_false;
} /* end if block for case of nvals > 1 */
} /* end calc of new centroid */
} /* end of loop down input trace */
/* Store values */
for (i = 0; i < nt; ++i) {
tr.data[i] = ct[i];
}
/* Set header values and write centroid trace */
tr.ns = nt;
puttr(&tr);
} while (gettr(&tr));
return(CWP_Exit());
}
int main(int argc, char **argv)
{
char *plotcmd; /* build pswigb command for popen */
float *trbuf; /* trace buffer */
FILE *plotfp; /* fp for plot data */
int nt; /* number of samples on trace */
int ntr; /* number of traces */
int verbose; /* verbose flag */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
cwp_Bool seismic; /* is this seismic data? */
cwp_Bool have_ntr=cwp_false;/* is ntr known from header or user? */
char *tmpdir; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false;/* true for user given path */
char *cwproot; /* value of CWPROOT environment variable*/
char *bindir; /* directory path for tmp files */
/* Support for irregularly spaced data */
cwp_String key; /* header key word with x2 information */
cwp_String type1=NULL; /* ... its type */
int index1=0; /* ... its index */
Value val; /* value of key */
Value scale; /* Value of scaler */
cwp_String type2=NULL; /* ... its type */
int index2=0; /* ... its index */
cwp_Bool isDepth=cwp_false; /* Is this key a type of depth? */
cwp_Bool isCoord=cwp_false; /* Is this key a type of coordinate? */
cwp_Bool irregular=cwp_false; /* if true, reading x2 from header */
cwp_String x2string; /* string of x2 values */
off_t x2len; /* ... its length */
cwp_String style; /* style parameter */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
seismic = ISSEISMIC(tr.trid);
nt = tr.ns;
ntr = tr.ntr;
if (ntr) have_ntr = cwp_true;
if (!getparint("verbose", &verbose)) verbose=0;
if (!getparfloat("d1", &d1)) {
if (tr.d1) d1 = tr.d1;
else if (tr.dt) d1 = ((double) tr.dt)/1000000.0;
else {
if (seismic) {
d1 = 0.004;
warn("tr.dt not set, assuming dt=0.004");
} else { /* non-seismic data */
d1 = 1.0;
warn("tr.d1 not set, assuming d1=1.0");
}
}
}
if (!getparfloat("f1", &f1)) {
if (tr.f1) f1 = tr.f1;
else if (tr.delrt) f1 = (float) tr.delrt/1000.0;
else f1 = 0.0;
}
/* Get or set ntr */
if (getparint("n2", &ntr) || getparint("ntr", &ntr)) have_ntr = cwp_true;
if (!getparfloat("d2", &d2)) d2 = (tr.d2) ? tr.d2 : 1.0;
if (!getparfloat("f2", &f2)) {
if (tr.f2) f2 = tr.f2;
else if (tr.tracr) f2 = (float) tr.tracr;
else if (tr.tracl) f2 = (float) tr.tracl;
else if (seismic) f2 = 1.0;
else f2 = 0.0;
}
if (!getparstring("style", &style)) style = "seismic";
if (getparstring("key", &key)) {
type1 = hdtype(key);
if ( (index1 = getindex(key)) == -1 )
err("%s: keyword not in segy.h: '%s'", __FILE__, key);
irregular = cwp_true;
isDepth = IS_DEPTH(key);
isCoord = IS_COORD(key);
if (isDepth) {
index2 = getindex("scalel");
type2 = hdtype("scalel");
} else if (isCoord) {
index2 = getindex("scalco");
type2 = hdtype("scalco");
}
}
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* See if CWPBIN environment variable is not set */
if (!(bindir = getenv("CWPBIN"))) { /* construct bindir from CWPROOT */
bindir = (char *) emalloc(BUFSIZ);
/* Get value of CWPROOT environment variable */
if (!(cwproot = getenv("CWPROOT"))) cwproot ="" ;
if (STREQ(cwproot, "")) {
warn("CWPROOT environment variable is not set! ");
err("Set CWPROOT in shell environment as per instructions in CWP/SU Installation README files");
}
/* then bindir = $CWPROOT/bin */
sprintf(bindir, "%s/bin", cwproot);
}
strcat(bindir,"/"); /* put / at the end of bindir */
/* Allocate trace buffer */
trbuf = ealloc1float(nt);
if (!have_ntr || irregular ) { /* count traces */
if (verbose) {
if (irregular) {
warn("trace spacing from header field %s",key);
warn("... getting positions");
} else {
warn("n2 not getparred and "
"ntr header field not set");
warn(".... counting traces");
}
}
/* Create temporary "file" to hold data */
if (STREQ(tmpdir,"")) {
datafp = etmpfile();
if (irregular) x2fp = etmpfile();
if (verbose) warn("using tmpfile() call");
} else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(datafile, temporary_filename(directory));
strcpy(x2file, temporary_filename(directory));
/* Handle user interrupts */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
datafp = efopen(datafile, "w+");
if (irregular) x2fp = efopen(x2file, "w+");
istmpdir=cwp_true;
if (verbose)
warn("putting temporary files in %s", directory);
}
/* Loop over input data and read to temporary file */
ntr = 0;
if(irregular ) {
float x,xmin=FLT_MAX,xmax=-FLT_MAX;
fprintf(x2fp,"x2=");
do {
if(ntr) fprintf(x2fp,",");
++ntr;
gethval(&tr,index1,&val);
if (isDepth || isCoord) {
gethval(&tr,index2,&scale);
x = (float) (vtod(type1,val) *
pow(10.0,vtod(type2,scale)));
} else
x = vtof(type1,val);
fprintf(x2fp,"%g",x);
xmin = MIN(xmin,x);
xmax = MAX(xmax,x);
if (isDepth && STREQ(style,"vsp")) {
int i;
for (i = 0; i < nt; ++i) tr.data[i] *= -1.0;
}
efwrite(tr.data, FSIZE, nt, datafp);
} while (gettr(&tr));
/* Flip vertical axis if style = vsp */
if (isDepth && STREQ(style,"vsp")) {
fprintf(x2fp," x2beg=%g x2end=%g",xmax,xmin);
style = "normal";
}
if(xmin==xmax) {
warn("values in header %s all equal,",key);
warn("using f2=%f d2=%f",f2,d2);
irregular=cwp_false;
have_ntr=cwp_false;
efclose(x2fp);
if (istmpdir) eremove(x2file);
}
} else {
do {
++ntr;
efwrite(tr.data, FSIZE, nt, datafp);
} while (gettr(&tr));
/* Save naive user */
if (STREQ(style,"vsp")) {
style = "normal";
warn("style=vsp requires key= to be set");
}
}
}
/* Set up pswigb command line */
if (irregular ) {
x2len = (off_t) eftell( x2fp );
x2string = (char *) emalloc( ++x2len );
rewind(x2fp);
fread(x2string,sizeof(char),x2len,x2fp);
plotcmd = (char *) emalloc(x2len+BUFSIZ);
if (STREQ(style,"vsp")) {
style = "normal";
}
sprintf(plotcmd, "%spswigb n1=%d d1=%f f1=%f %s style=%s", bindir,
nt, d1, f1, x2string, style);
free(x2string);
} else {
if (STREQ(style,"vsp")) {
style = "normal";
}
plotcmd = (char *) emalloc(BUFSIZ);
sprintf(plotcmd,
"%spswigb n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f style=%s", bindir,
nt, ntr, d1, d2, f1, f2, style);
}
for (--argc, ++argv; argc; --argc, ++argv) {
if (strncmp(*argv, "d1=", 3) && /* skip those already set */
strncmp(*argv, "d2=", 3) &&
strncmp(*argv, "f1=", 3) &&
strncmp(*argv, "f2=", 3) &&
strncmp(*argv, "style=", 6)){
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe to pswigb and send the traces */
plotfp = epopen(plotcmd, "w");
free(plotcmd);
if (!have_ntr || irregular) { /* send out stored traces one by one */
rewind(datafp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread (trbuf, FSIZE, nt, datafp);
efwrite(trbuf, FSIZE, nt, plotfp);
}
}
} else { /* just pump out traces and let pswigb do the work */
do {
efwrite(tr.data, FSIZE, nt, plotfp);
} while (gettr(&tr));
}
/* Clean up */
epclose(plotfp);
if (!have_ntr) {
efclose(datafp);
if (istmpdir) eremove(datafile);
}
if (irregular) {
efclose(x2fp);
if (istmpdir) eremove(x2file);
}
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
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()) ;
}
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;
}
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;
}
static void makeone (float **ts, float **as, float **sgs,
float **tg, float **ag, float **sgg, float ex, float ez, float dx,
float dz, float fx, float vs0, float vg0, int ls, Wavelet *w,
int nr, Reflector *r, int nt, float dt, float ft, float *trace)
/*****************************************************************************
Make one synthetic seismogram
******************************************************************************
Input:
**v array[nx][nz] containing velocities
nz number of z samples
dz z sampling interval
nx number of x samples
dx x sampling interval
fx first x sample
ls =1 for line source amplitudes; =0 for point source
w wavelet to convolve with trace
xs x coordinate of source
xg x coordinate of receiver group
nr number of reflectors
r array[nr] of reflectors
nt number of time samples
dt time sampling interval
ft first time sample
Output:
trace array[nt] containing synthetic seismogram
*****************************************************************************/
{
int it,ir,is,ns,ix,iz;
float ar,ds,xd,zd,cd,sd,xi,zi,ci,cr,time,amp,sx,sz,
tsd,asd,sgsd,tgd,agd,sggd,
*temp;
ReflectorSegment *rs;
int lhd=LHD,nhd=NHD;
static float hd[NHD];
static int madehd=0;
/* if half-derivative filter not yet made, make it */
if (!madehd) {
mkhdiff(dt,lhd,hd);
madehd = 1;
}
/* zero trace */
for (it=0; it<nt; ++it)
trace[it] = 0.0;
/* loop over reflectors */
for (ir=0; ir<nr; ++ir) {
/* amplitude, number of segments, segment length */
ar = r[ir].a;
ns = r[ir].ns;
ds = r[ir].ds;
rs = r[ir].rs;
/* loop over diffracting segments */
for (is=0; is<ns; ++is) {
/* diffractor midpoint, unit-normal, and length */
xd = rs[is].x;
zd = rs[is].z;
cd = rs[is].c;
sd = rs[is].s;
/* check range of reflector */
if(xd<fx || xd>=ex || zd>=ez)
continue;
/* determine sample indices */
xi = (xd-fx)/dx;
ix = xi;
zi = zd/dz;
iz = zi;
/* bilinear interpolation */
sx = xi-ix;
sz = zi-iz;
tsd = (1.0-sz)*((1.0-sx)*ts[ix][iz] +
sx*ts[ix+1][iz]) +
sz*((1.0-sx)*ts[ix][iz+1] +
sx*ts[ix+1][iz+1]);
asd = (1.0-sz)*((1.0-sx)*as[ix][iz] +
sx*as[ix+1][iz]) +
sz*((1.0-sx)*as[ix][iz+1] +
sx*as[ix+1][iz+1]);
sgsd = (1.0-sz)*((1.0-sx)*sgs[ix][iz] +
sx*sgs[ix+1][iz]) +
sz*((1.0-sx)*sgs[ix][iz+1] +
sx*sgs[ix+1][iz+1]);
tgd = (1.0-sz)*((1.0-sx)*tg[ix][iz] +
sx*tg[ix+1][iz]) +
sz*((1.0-sx)*tg[ix][iz+1] +
sx*tg[ix+1][iz+1]);
agd = (1.0-sz)*((1.0-sx)*ag[ix][iz] +
sx*ag[ix+1][iz]) +
sz*((1.0-sx)*ag[ix][iz+1] +
sx*ag[ix+1][iz+1]);
sggd = (1.0-sz)*((1.0-sx)*sgg[ix][iz] +
sx*sgg[ix+1][iz]) +
sz*((1.0-sx)*sgg[ix][iz+1] +
sx*sgg[ix+1][iz+1]);
/* cosines of incidence and reflection angles */
ci = cd*cos(asd)+sd*sin(asd);
cr = cd*cos(agd)+sd*sin(agd);
/* two-way time and amplitude */
time = tsd+tgd;
if (ls)
amp = sqrt(vs0*vg0/(sgsd*sggd));
else
amp = sqrt(vs0*vg0/(sgsd*sggd*(sgsd+sggd)));
amp *= ABS(ci+cr)*ar*ds;
/* add sinc wavelet to trace */
addsinc(time,amp,nt,dt,ft,trace);
}
}
/* allocate workspace */
temp = ealloc1float(nt);
/* apply half-derivative filter to trace */
conv(nhd,-lhd,hd,nt,0,trace,nt,0,temp);
/* convolve wavelet with trace */
conv(w->lw,w->iw,w->wv,nt,0,temp,nt,0,trace);
/* free workspace */
free1float(temp);
}
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) {
char *coeff_x, *coeff_x2, *coeff_x3, file[BUFSIZ];
cwp_Bool active = TRUE;
struct GRD_HEADER grd_x, grd_x2, grd_x3;
struct GMT_EDGEINFO edgeinfo_x, edgeinfo_x2, edgeinfo_x3;
struct GMT_BCR bcr_x, bcr_x2, bcr_x3;
short check, verbose;
int nz, ntr, ns;
double value, scale_factor, dz, x_loc, y_loc;
double weight_x, weight_x2, weight_x3;
double value_coeff_x, value_coeff_x2, value_coeff_x3, tr_sec, dt_sec;
float depth_input, amp_output, *tr_amp, *depth;
register int k, n;
initargs(argc, argv);
argc = GMT_begin (argc, argv);
if (!getparstring("coeff_x", &coeff_x)) {
fprintf ( stderr, "Must supply Coefficient_X GMT grid (COEFF_X Parameter) --> exiting\n" );
return EXIT_FAILURE;
}
if (!getparstring("coeff_x2", &coeff_x2)) {
fprintf ( stderr, "Must supply Coefficient_X2 GMT grid (COEFF_X2 Parameter)--> exiting\n" );
return EXIT_FAILURE;
}
if (!getparstring("coeff_x3", &coeff_x3)) {
fprintf ( stderr, "Must supply Coefficient_X3 GMT grid (COEFF_X3 Parameter)--> exiting\n" );
return EXIT_FAILURE;
}
if (!getparshort("verbose" , &verbose)) verbose = 0;
if (!getpardouble("weight_x", &weight_x)) weight_x = 1.0;
if (!getpardouble("weight_x2", &weight_x2)) weight_x2 = 1.0;
if (!getpardouble("weight_x3", &weight_x3)) weight_x3 = 1.0;
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "X1 Coefficient GMT grid file name = %s\n", coeff_x );
fprintf ( stderr, "X2 Coefficient GMT grid file name = %s\n", coeff_x2 );
fprintf ( stderr, "X3 Coefficient GMT grid file name = %s\n", coeff_x3 );
fprintf ( stderr, "X1 Grid Weighting Value = %f\n", weight_x );
fprintf ( stderr, "X2 Grid Weighting Value = %f\n", weight_x2 );
fprintf ( stderr, "X3 Grid Weighting Value = %f\n", weight_x3 );
fprintf ( stderr, "\n" );
}
weight_x = 1.0 / weight_x;
weight_x2 = 1.0 / weight_x2;
weight_x3 = 1.0 / weight_x3;
GMT_boundcond_init (&edgeinfo_x);
GMT_boundcond_init (&edgeinfo_x2);
GMT_boundcond_init (&edgeinfo_x3);
GMT_grd_init (&grd_x, argc, argv, FALSE);
GMT_grd_init (&grd_x2, argc, argv, FALSE);
GMT_grd_init (&grd_x3, argc, argv, FALSE);
if (GMT_read_grd_info (coeff_x, &grd_x)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x2, &grd_x2)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x3, &grd_x3)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
f1 = (float *) GMT_memory (VNULL, (size_t)((grd_x.nx + 4) * (grd_x.ny + 4)), sizeof(float), GMT_program);
f2 = (float *) GMT_memory (VNULL, (size_t)((grd_x2.nx + 4) * (grd_x2.ny + 4)), sizeof(float), GMT_program);
f3 = (float *) GMT_memory (VNULL, (size_t)((grd_x3.nx + 4) * (grd_x3.ny + 4)), sizeof(float), GMT_program);
GMT_pad[0] = GMT_pad[1] = GMT_pad[2] = GMT_pad[3] = 2;
GMT_boundcond_param_prep (&grd_x, &edgeinfo_x);
GMT_boundcond_param_prep (&grd_x2, &edgeinfo_x2);
GMT_boundcond_param_prep (&grd_x3, &edgeinfo_x3);
GMT_boundcond_set (&grd_x, &edgeinfo_x, GMT_pad, f1);
GMT_boundcond_set (&grd_x2, &edgeinfo_x2, GMT_pad, f2);
GMT_boundcond_set (&grd_x3, &edgeinfo_x3, GMT_pad, f3);
value = 0.0;
GMT_bcr_init (&grd_x, GMT_pad, active, value, &bcr_x);
GMT_bcr_init (&grd_x2, GMT_pad, active, value, &bcr_x2);
GMT_bcr_init (&grd_x3, GMT_pad, active, value, &bcr_x3);
GMT_read_grd (coeff_x, &grd_x, f1, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x2, &grd_x2, f2, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x3, &grd_x3, f3, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
/* Get info from first trace */
ntr = gettra (&tr, 0);
ns = tr.ns;
dt_sec = tr.dt * 0.000001;
scale_factor = tr.scalco;
if (scale_factor < 0.0 ) scale_factor *= -1.0;
if (scale_factor == 0.0 ) scale_factor = 1.0;
if (!getpardouble ("dz",&dz)) dz = 2.0;
if (!getparint ("nz",&nz)) nz = ns;
if ( verbose ) {
fprintf ( stderr, "Output depth sample rate = %f\n", dz );
fprintf ( stderr, "Coordinate scale factor = %f\n", scale_factor );
fprintf ( stderr, "Number of output depth samples per trace = %d\n", nz );
fprintf ( stderr, "number of traces = %d, number of samples per trace = %d\n", ntr, ns );
fprintf ( stderr, "time sample rate (seconds) = %f\n", dt_sec );
}
rewind (stdin);
depth = ealloc1float ( ns );
tr_amp = ealloc1float ( nz );
/* Main loop over traces */
for ( k = 0; k < ntr; ++k ) {
gettr (&tr);
x_loc = tr.sx / scale_factor;
y_loc = tr.sy / scale_factor;
check = 0;
if ( x_loc >= grd_x.x_min && x_loc <= grd_x.x_max && y_loc >= grd_x.y_min && y_loc <= grd_x.y_max ) check = 1;
if ( check ) {
value_coeff_x = GMT_get_bcr_z (&grd_x, x_loc, y_loc, f1, &edgeinfo_x, &bcr_x);
value_coeff_x2 = GMT_get_bcr_z (&grd_x2, x_loc, y_loc, f2, &edgeinfo_x2, &bcr_x2);
value_coeff_x3 = GMT_get_bcr_z (&grd_x3, x_loc, y_loc, f3, &edgeinfo_x3, &bcr_x3);
if ( verbose ) fprintf ( stderr, "Trace num = %d, X-Loc = %f, Y-Loc = %f, X Coefficient = %0.10f, X2 Coefficient = %0.10f, X3 Coefficient = %0.10f\n",
k+1, x_loc, y_loc, value_coeff_x, value_coeff_x2, value_coeff_x3 );
for ( n=0; n < ns; ++n ) {
tr_amp[n] = tr.data[n];
tr_sec = n * dt_sec;
depth[n] = (((value_coeff_x*tr_sec)*weight_x) + ((value_coeff_x2*pow(tr_sec,2))*weight_x2) + ((value_coeff_x3*pow(tr_sec,3))*weight_x3)) * -1.0;
if ( verbose == 2 ) fprintf ( stderr, "Trace no. = %5d, Sample = %5d, TWT (secs.) = %.4f, Depth (feet) = %.4f\n", k, n, tr_sec, depth[n] );
}
for ( n=0; n < nz; ++n ) {
depth_input = n * dz;
intlin ( ns, depth, tr_amp, tr_amp[0], tr_amp[ns-1], 1, &depth_input, &_output );
dtr.data[n] = amp_output;
}
dtr.tracl = tr.tracl;
dtr.tracr = tr.tracr;
dtr.ep = tr.ep;
dtr.ns = nz;
dtr.dt = nint (dz * 1000.0);
dtr.sx = tr.sx;
dtr.sy = tr.sy;
dtr.trid = 1;
dtr.fldr = tr.fldr;
dtr.cdp = tr.cdp ;
puttr (&dtr);
} else {
fprintf ( stderr, "input trace = %d, xloc = %.0f yloc = %.0f is out of bounds\n", k, x_loc, y_loc);
}
}
GMT_free ((void *)f1);
GMT_free ((void *)f2);
GMT_free ((void *)f3);
GMT_end (argc, argv);
free1float (depth);
free1float (tr_amp);
return (0);
}
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;
}
