void rc1_fft(REAL *data, complex *cdata, int n, int sign)
{
int j;
double *datft;
if (NINT(pow(2.0, (double)NINT(log((double)n)/log(2.0)))) != n) {
if (npfar(n) == n) pfarc(sign,n,data,cdata);
else rcdft(data,cdata,n,sign);
}
else {
datft = (double *)malloc(n*sizeof(double));
if (datft == NULL) fprintf(stderr,"rc1_fft: memory allocation error\n");
for (j = 0; j < n; j++) datft[j] = (double)data[j];
realfft(n, datft);
cdata[0].i = 0.0;
for (j = 0; j < n/2; j++) {
cdata[j].r = (REAL)datft[j];
cdata[j+1].i = sign*(REAL)datft[n-j-1];
}
cdata[n/2].r = datft[n/2];
cdata[n/2].i = 0.0;
free(datft);
}
return;
}
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);
}
void rcm_fft(REAL *data, complex *cdata, int n1, int n2, int ldr, int ldc, int sign)
{
int j, i;
double *datft;
if (NINT(pow(2.0, (double)NINT(log((double)n1)/log(2.0)))) != n1) {
if (npfar(n1) == n1) {
if (ldr == n1 && ldc == n2) {
pfa2rc(sign, 1, n1, n2, data, cdata);
}
else {
for (i = 0; i < n2; i++) {
pfarc(sign, n1, &data[i*ldr], &cdata[i*ldc]);
}
}
}
else {
for (i = 0; i < n2; i++) {
rcdft(&data[i*ldr], &cdata[i*ldc], n1, sign);
}
}
}
else {
datft = (double *)malloc(n1*sizeof(double));
if (datft == NULL) fprintf(stderr,"rcm_fft: memory allocation error\n");
for (i = 0; i < n2; i++) {
for (j = 0; j < n1; j++) datft[j] = (double)data[i*ldr+j];
realfft(n1, datft);
cdata[i*ldc].i = 0.0;
for (j = 0; j < n1/2; j++) {
cdata[i*ldc+j].r = (REAL)datft[j];
cdata[i*ldc+j+1].i = sign*(REAL)datft[n1-j-1];
}
cdata[i*ldc+n1/2].r = (REAL)datft[n1/2];
cdata[i*ldc+n1/2].i = 0.0;
}
free(datft);
}
return;
}
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);
}
int
main(int argc, char **argv)
{
float c; /* speed */
float dt; /* sampling rate */
int nt; /* number of samples */
size_t ntsize; /* ... in bytes */
int nshot; /* number of shots */
int nrec; /* number of receivers */
float x0, y0, z0; /* point scatterer location */
float sxmin, symin, szmin; /* first shot location */
float gxmin, gymin, gzmin; /* first receiver location */
float dsx, dsy, dsz; /* step in shot location */
float dgx, dgy, dgz; /* step in receiver location */
float sx, sy, sz; /* shot location */
float gx, gy, gz; /* receiver location */
float rs; /* distance to shot */
float rg; /* distance to receiver */
float d; /* rs + rg */
float t; /* total travel time */
float k; /* constant part of response */
register float *rt; /* real trace */
register complex *ct; /* complex transformed trace */
int nfft; /* size of fft */
int nfby2; /* nfft/2 */
int nfby2p1; /* nfft/2 + 1 */
size_t nzeros; /* padded zeroes in bytes */
float spread; /* 3-D spreading factor */
register int i; /* counter */
register int s; /* shot counter */
register int g; /* receiver counter */
register int tracl; /* trace counter */
float amplitude[1]; /* amplitude */
float *tout; /* times[nt] for interpolation */
/* Initialize */
initargs(argc, argv);
requestdoc(0);
/* Get parameters */
if (!getparint("nshot", &nshot)) nshot = 1;
if (!getparint("nrec", &nrec)) nrec = 1;
if (!getparint("nt", &nt)) nt = 256;
if (!getparfloat("c", &c)) c = 5000.0;
if (!getparfloat("dt", &dt)) dt = 0.004;
if (!getparfloat("x0", &x0)) x0 = 1000.0;
if (!getparfloat("y0", &y0)) y0 = 0.0;
if (!getparfloat("z0", &z0)) z0 = 1000.0;
if (!getparfloat("sxmin", &sxmin)) sxmin = 0.0;
if (!getparfloat("symin", &symin)) symin = 0.0;
if (!getparfloat("szmin", &szmin)) szmin = 0.0;
if (!getparfloat("gxmin", &gxmin)) gxmin = 0.0;
if (!getparfloat("gymin", &gymin)) gymin = 0.0;
if (!getparfloat("gzmin", &gzmin)) gzmin = 0.0;
if (!getparfloat("dsx", &dsx)) dsx = 100.0;
if (!getparfloat("dsy", &dsy)) dsy = 0.0;
if (!getparfloat("dsz", &dsz)) dsz = 0.0;
if (!getparfloat("dgx", &dgx)) dgx = 100.0;
if (!getparfloat("dgy", &dgy)) dgy = 0.0;
if (!getparfloat("dgz", &dgz)) dgz = 0.0;
/* Set the constant header fields */
tr.ns = nt;
tr.dt = dt * 1000000.0;
ntsize = nt * FSIZE;
/* Set up for fft */
nfft = npfaro(nt, LOOKFAC * nt);
if (nfft >= SU_NFLTS || nfft >= PFA_MAX)
err("Padded nt=%d -- too big", nfft);
nfby2 = nfft / 2;
nfby2p1 = nfby2 + 1;
nzeros = (nfft - nt) * FSIZE;
/* Allocate fft arrays */
rt = ealloc1float(nfft);
ct = ealloc1complex(nfby2p1);
/* Set the constant in the response amplitude
including scale for inverse fft below */
k = 1.0 / (4.0 * c * c * dt * dt * dt * nfft * nfft * nfft);
/* Compute output times for interpolation */
tout = ealloc1float(nt);
for (i=0; i<nt; i++) tout[i]=i*dt;
/* Create the traces */
tracl = 0;
for (s = 0; s < nshot; ++s) { /* loop over shots */
sx = sxmin + s * dsx;
sy = symin + s * dsy;
sz = szmin + s * dsz;
rs = sqrt((sx - x0)*(sx - x0) + (sy - y0)*(sy - y0) +
(sz - z0)*(sz - z0));
for (g = 0; g < nrec; ++g) { /* loop over receivers */
memset( (void *) tr.data, 0, ntsize);
gx = gxmin + g * dgx;
gy = gymin + g * dgy;
gz = gzmin + g * dgz;
rg = sqrt((gx - x0)*(gx - x0) + (gy - y0)*(gy - y0) +
(gz - z0)*(gz - z0));
d = rs + rg;
t = d/c;
spread = rs*rg;
amplitude[0] = k/spread;
/* Distribute response over full trace */
ints8r(1,dt,t,amplitude,0,0,nt,tout,tr.data);
/* Load trace into rt (zero-padded) */
memcpy( (void *) rt, (const void *) tr.data, ntsize);
memset( (void *) (rt + nt), 0, nzeros);
/* FFT */
pfarc(1, nfft, rt, ct);
/* Multiply by omega^2 */
for (i = 0; i < nfby2p1; ++i)
ct[i] = crmul(ct[i], i*i);
/* Invert and take real part */
pfacr(-1, nfft, ct, rt);
/* Load traces back in */
memcpy( (void *) tr.data, (const void *) rt, ntsize);
/* Set header fields---shot fields set above */
tr.tracl = tr.tracr = ++tracl;
tr.fldr = 1 + s;
tr.tracf = 1 + g;
tr.sx = NINT(sx);
tr.sy = NINT(sy);
tr.selev = -NINT(sz); /* above sea level > 0 */
tr.gx = NINT(gx);
tr.gy = NINT(gy);
tr.gelev = -NINT(gz); /* above sea level > 0 */
/* If along a coordinate axis, use a signed offset */
tr.offset = sqrt((sx - gx)*(sx - gx) +
(sy - gy)*(sy - gy) +
(sz - gz)*(sz - gz));
if (dgy == 0 && dgz == 0)
tr.offset = NINT(dsx > 0 ? gx - sx : sx - gx);
if (dgx == 0 && dgz == 0)
tr.offset = NINT(dsy > 0 ? gy - sy : sy - gy);
if (dgx == 0 && dgy == 0)
tr.offset = NINT(dsz > 0 ? gz - sz : sz - gz);
puttr(&tr);
} /* end loop on receivers */
} /* end loop on shots */
return(CWP_Exit());
}
/* September 1995 */
#include "stratInv.h"
segy tr; /* reading data */
void inputData(char* dataFile)
{
/* declaration of variables */
int iS, iR, iF, iF1, iF2; /* generic counters */
int ns; /* # of samples */
int wL; /* window length */
float *buffer = NULL; /* to input data */
float window; /* windowing purposes */
complex *bufferC = NULL; /* to Fourier transform the input data */
FILE *fp; /* input file */
/* memory for bufferC */
bufferC = alloc1complex(info->nSamples / 2 + 1);
fp = fopen(dataFile,"r");
if (fp == NULL)
err("Can't open input data file!\n");
for (iR = 0; iR < info->nR; iR++)
{
fgettr(fp, &tr);
ns = tr.ns;
/* DD
fprintf(stderr, "ns %d\n", ns);*/
/* allocating memory */
if (iR == 0) buffer = alloc1float(MAX(ns, info->nSamples));
/* reseting */
for (iS = 0; iS < MAX(ns, info->nSamples); iS++) buffer[iS] = 0;
memcpy(buffer, tr.data, ns * FSIZE);
/* buffer -> dataObs and compensating for complex frequency */
for (iS = 0; iS < info->nSamples; iS++)
{
buffer[iS] *= exp(-info->tau * iS * dt);
/* DD
fprintf(stderr, "buffer[%d] : %f\n", iS, buffer[iS]);*/
}
/* going to the Fourier domain */
pfarc(-1, info->nSamples, buffer, bufferC);
/* windowing (PERC_WINDOW) spectrum */
iF1 = NINT(info->f1 / info->dF);
iF2 = NINT(info->f2 / info->dF);
wL = info->nF * PERC_WINDOW / 2;
wL = 2 * wL + 1;
for (iS = 0, iF = 0; iF < info->nSamples / 2 + 1; iF++)
{
window = 0;
if (iF < iF1 || iF >= iF2)
{
bufferC[iF] = cmplx(0, 0);
}
else if (iF - iF1 < (wL - 1) / 2)
{
window =
.42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferC[iF].r *= window; bufferC[iF].i *= window;
iS++;
}
else if (iF - iF1 >= info->nF - (wL - 1) / 2)
{
iS++;
window =
.42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferC[iF].r *= window; bufferC[iF].i *= window;
}
}
/* going back to time domain */
pfacr(1, info->nSamples, bufferC, buffer);
/* copying to dataObs within target window and scaling */
for (iF = 0, iS = NINT(t1 / dt); iS <= NINT(t2 / dt); iS++, iF++)
{
dataObs[iR][iF] = (scaleData * buffer[iS]) / (float) info->nSamples;
/* DD
fprintf(stderr, "%d %d %f %f %f %f\n", iR, iF, dataObs[iR][iF],
info->f1, info->f2, scaleData);*/
}
}
/* DD
fprintf(stderr, "energy %f\n", auxm1 / (nDM * info->nR));
fwrite(&dataObs[0][0], sizeof(float), nDM * info->nR, stdout);
exit(-1);*/
/* freeing memory */
free1float(buffer);
free1complex(bufferC);
fclose(fp);
}
void do_minphdec(float *tr,int nt, float *filter,int fnl,int fnr,float prw)
{
float *rtr;
float *rtx;
complex *f;
complex *w;
complex a;
int iamp;
float amp;
float ampm=-1.0e+20;
float amps;
float *am;
float *ph;
float mean=0.0;
float sum=0.0;
int nfftc;
int nf;
int i,j; /* counter */
float snfftc;
/* Set up pfa fft */
nfftc = npfao(nt,LOOKFAC*nt);
if (nfftc >= SU_NFLTS || nfftc >= PFA_MAX)
err("Padded nt=%d--too big", nfftc);
nf = nfftc/2 + 1;
snfftc=1.0/nfftc;
rtr = ealloc1float(nfftc);
rtx = ealloc1float(nf);
f = ealloc1complex(nfftc);
w = ealloc1complex(nfftc);
am = ealloc1float(nf);
ph = ealloc1float(nf);
/* clean the arrays */
memset( (void *) w, (int) '\0', nfftc*sizeof(complex));
memset( (void *) rtr, (int) '\0', nfftc*FSIZE);
/* Cross correlation */
xcor(nt,0,tr,nt,0,tr,nf,0,rtr);
/* FFT */
pfarc(1, nfftc,rtr,w);
/* stabilize */
for(i=0;i<nf;i++) {
am[i] += am[i]*prw;
}
/* Normalize */
for(i=0;i<nf;i++) {
a=w[i];
am[i]= sqrt(a.r*a.r+a.i*a.i);
sum += am[i];
if(am[i]!=0) ph[i] = atan2(a.i,a.r);
else ph[i]=0;
}
sum *= 1.0/nf;
sum = 1.0/sum;
sscal(nf,sum,am,1);
/* Smooth the apmlitude spectra */
if(fnl!=0) conv (fnl+fnr+1,-fnl,filter,nf,0,am,nf,0,am);
fprintf(stderr," %f\n",sum);
for(i=0;i<nf;i++) {
w[i].r = am[i]*cos(ph[i]);
w[i].i = am[i]*sin(ph[i]);
}
for(i=nf,j=nf-1;i<nfftc;i++,j--) {
w[i].r = am[j]*cos(ph[j]);
w[i].i = am[j]*sin(ph[j]);
}
/* log spectra */
for (i = 0; i < nfftc; ++i) w[i] =
crmul(clog(cmul(w[i],conjg(w[i]))),0.5);
/* Hilbert transform */
pfacc(-1,nfftc,w);
for (i=0; i<nfftc; ++i) {
w[i].r *=snfftc;
w[i].i *=snfftc;
}
for(i=1;i<nfftc/2;i++) w[i] = cadd(w[i],w[i]);
for(i=nfftc/2;i<nfftc;i++) w[i] = cmplx(0,0);
pfacc(1,nfftc,w);
/* end of Hilbert transform */
/* exponentiate */
for(i=0;i<nfftc;i++) w[i] = cexp(w[i]);
/* inverse filter */
for(i=0;i<nfftc;i++) f[i] = cdiv(cmplx(1.0,0),w[i]);
/* Load trace into tr (zero-padded) */
memset( (void *) w, (int) '\0',nfftc*sizeof(complex));
for(i=0;i<nt;i++) w[i].r = tr[i];
/* Trace to frequency domain */
pfacc(1,nfftc,w);
/* apply filter */
for(i=0;i<nfftc;i++) w[i] = cmul(w[i],f[i]);
/* Time domain */
pfacr(-1, nfftc,w,rtr);
for(i=0;i<nt;i++) rtr[i] *=snfftc;
memcpy( (void *) tr, (const void *) rtr, nt*FSIZE);
free1float(rtr);
free1float(am);
free1float(ph);
free1complex(f);
free1complex(w);
}
int main( int argc, char *argv[] )
{
int ntr=0; /* number of traces */
int ntrv=0; /* number of traces */
int ns=0;
int nsv=0;
float dt;
float dtv;
cwp_String fs;
cwp_String fv;
FILE *fps;
FILE *fpv;
FILE *headerfp;
float *data; /* data matrix of the migration volume */
float *vel; /* velocity matrix */
float *velfi; /* velocity function interpolated to ns values*/
float *velf; /* velocity function */
float *vdt;
float *ddt;
float *ap; /* array of apperture values in m */
float apr; /* array of apperture values in m */
int *apt=NULL; /* array of apperture time limits in mig. gath*/
float r; /* maximum radius with a given apperture */
float ir2; /* r/d2 */
float ir3; /* r/d3 */
float d2; /* spatial sampling int. in dir 2. */
float d3; /* spatial sampling int. in dir 3. */
float **mgd=NULL; /* migration gather data */
float *migt; /* migrated data trace */
int **mgdnz=NULL; /* migration gather data non zero samples*/
float dm; /* migration gather spatial sample int. */
int im; /* number of traces in migration gather */
int *mtnz; /* migrated trace data non zero smaples */
char **dummyi; /* index array that the trace contains zeros only */
float fac; /* velocity scale factor */
int sphr; /* spherical divergence flag */
int imt; /* mute time sample of trace */
float tmp;
int imoff;
int **igtr=NULL;
int nigtr;
int n2;
int n3;
int verbose;
/* phase shift filter stuff */
float power; /* power of i omega applied to data */
float amp; /* amplitude associated with the power */
float arg; /* argument of power */
float phasefac; /* phase factor */
float phase; /* phase shift = phasefac*PI */
complex exparg; /* cexp(I arg) */
register float *rt; /* real trace */
register complex *ct; /* complex transformed trace */
complex *filt; /* complex power */
float omega; /* circular frequency */
float domega; /* circular frequency spacing (from dt) */
float sign; /* sign in front of i*omega default -1 */
int nfft; /* number of points in nfft */
int nf; /* number of frequencies (incl Nyq) */
float onfft; /* 1 / nfft */
size_t nzeros; /* number of padded zeroes in bytes */
initargs(argc, argv);
requestdoc(1);
MUSTGETPARSTRING("fs",&fs);
MUSTGETPARSTRING("fv",&fv);
MUSTGETPARINT("n2",&n2);
MUSTGETPARINT("n3",&n3);
MUSTGETPARFLOAT("d2",&d2);
MUSTGETPARFLOAT("d3",&d3);
if (!getparfloat("dm", &dm)) dm=(d2+d3)/2.0;
/* open datafile */
fps = efopen(fs,"r");
fpv = efopen(fv,"r");
/* Open tmpfile for headers */
headerfp = etmpfile();
/* get information from the first data trace */
ntr = fgettra(fps,&tr,0);
if(n2*n3!=ntr) err(" Number of traces in file %d not equal to n2*n3 %d \n",
ntr,n2*n3);
ns=tr.ns;
if (!getparfloat("dt", &dt)) dt = ((float) tr.dt)/1000000.0;
if (!dt) {
dt = .002;
warn("dt not set, assumed to be .002");
}
/* get information from the first velocity trace */
ntrv = fgettra(fpv,&trv,0);
if(ntrv!=ntr) err(" Number of traces in velocity file %d differ from %d \n",
ntrv,ntr);
nsv=trv.ns;
if (!getparfloat("dtv", &dtv)) dtv = ((float) trv.dt)/1000000.0;
if (!dtv) {
dtv = .002;
warn("dtv not set, assumed to be .002 for velocity");
}
if (!getparfloat("fac", &fac)) fac=2.0;
if (!getparint("verbose", &verbose)) verbose=0;
if (!getparint("sphr", &sphr)) sphr=0;
if (!getparfloat("apr", &apr)) apr=75;
apr*=3.141592653/180;
/* allocate arrays */
data = bmalloc(sizeof(float),ns,ntr);
vel = bmalloc(sizeof(float),nsv,ntr);
velf = ealloc1float(nsv);
velfi = ealloc1float(ns);
migt = ealloc1float(ns);
vdt = ealloc1float(nsv);
ddt = ealloc1float(ns);
ap = ealloc1float(ns);
mtnz = ealloc1int(ns);
dummyi = (char **) ealloc2(n2,n3,sizeof(char));
/* Times to do interpolation of velocity from sparse sampling */
/* to fine sampling of the data */
{ register int it;
for(it=0;it<nsv;it++) vdt[it]=it*dtv;
for(it=0;it<ns;it++) ddt[it]=it*dt;
}
/* Read traces into data */
/* Store headers in tmpfile */
ntr=0;
erewind(fps);
erewind(fpv);
{ register int i2,i3;
for(i3=0;i3<n3;i3++)
for(i2=0;i2<n2;i2++) {
fgettr(fps,&tr);
fgettr(fpv,&trv);
if(tr.trid > 2) dummyi[i3][i2]=1;
else dummyi[i3][i2]=0;
efwrite(&tr, 1, HDRBYTES, headerfp);
bmwrite(data,1,0,i3*n2+i2,ns,tr.data);
bmwrite(vel,1,0,i3*n2+i2,nsv,trv.data);
}
erewind(headerfp);
/* set up the phase filter */
power = 1.0;sign = 1.0;phasefac = 0.5;
phase = phasefac * PI;
/* Set up for fft */
nfft = npfaro(ns, LOOKFAC * ns);
if (nfft >= SU_NFLTS || nfft >= PFA_MAX)
err("Padded nt=%d -- too big", nfft);
nf = nfft/2 + 1;
onfft = 1.0 / nfft;
nzeros = (nfft - ns) * FSIZE;
domega = TWOPI * onfft / dt;
/* Allocate fft arrays */
rt = ealloc1float(nfft);
ct = ealloc1complex(nf);
filt = ealloc1complex(nf);
/* Set up args for complex power evaluation */
arg = sign * PIBY2 * power + phase;
exparg = cexp(crmul(I, arg));
{
register int i;
for (i = 0 ; i < nf; ++i) {
omega = i * domega;
/* kludge to handle omega=0 case for power < 0 */
if (power < 0 && i == 0) omega = FLT_MAX;
/* calculate filter */
amp = pow(omega, power) * onfft;
filt[i] = crmul(exparg, amp);
}
}
/* set up constants for migration */
if(verbose) fprintf(stderr," Setting up constants....\n");
r=0;
for(i3=0;i3<n3;i3++)
for(i2=0;i2<n2;i2++) {
if(dummyi[i3][i2] < 1) {
/* get the velocity function */
bmread(vel,1,0,i3*n2+i2,nsv,velf);
/* linear interpolation from nsv to ns values */
intlin(nsv,vdt,velf,velf[0],velf[nsv-1],ns,ddt,velfi);
/* Apply scale factor to velocity */
{ register int it;
for(it=0;it<ns;it++) velfi[it] *=fac;
}
/* compute maximum radius from apperture and velocity */
{ register int it;
for(it=0;it<ns;it++)
ap[it] = ddt[it]*velfi[it]*tan(apr)/2.0;
}
tmp = ap[isamax(ns,ap,1)];
if(tmp>r) r=tmp;
}
}
r=MIN(r,sqrt(SQR((n2-1)*d2)+SQR((n3-1)*d3)));
ir2 = (int)(2*r/d2)+1;
ir3 = (int)(2*r/d3)+1;
im = (int)(r/dm)+1;
/* allocate migration gather */
mgd = ealloc2float(ns,im);
mgdnz = ealloc2int(ns,im);
apt = ealloc1int(im);
/* set up the stencil for selecting traces */
igtr = ealloc2int(ir2*ir3,2);
stncl(r, d2, d3,igtr,&nigtr);
if(verbose) {
fprintf(stderr," Maximum radius %f\n",r);
fprintf(stderr," Maximum offset %f\n",
sqrt(SQR((n2-1)*d2)+SQR((n3-1)*d3)));
}
/* main processing loop */
for(i3=0;i3<n3;i3++)
for(i2=0;i2<n2;i2++) {
memset( (void *) tr.data, (int) '\0',ns*FSIZE);
if(dummyi[i3][i2] < 1) {
memset( (void *) mgd[0], (int) '\0',ns*im*FSIZE);
memset( (void *) mgdnz[0], (int) '\0',ns*im*ISIZE);
/* get the velocity function */
bmread(vel,1,0,i3*n2+i2,nsv,velf);
/* linear interpolation from nsv to ns values */
intlin(nsv,vdt,velf,velf[0],velf[nsv-1],ns,ddt,velfi);
/* Apply scale factor to velocity */
{ register int it;
for(it=0;it<ns;it++) velfi[it] *=fac;
}
/* create the migration gather */
{ register int itr,ist2,ist3;
for(itr=0;itr<nigtr;itr++) {
ist2=i2+igtr[0][itr];
ist3=i3+igtr[1][itr];
if(ist2 >= 0 && ist2 <n2)
if(ist3 >= 0 && ist3 <n3) {
if(dummyi[ist3][ist2] <1) {
imoff = (int) (
sqrt(SQR(igtr[0][itr]*d2)
+SQR(igtr[1][itr]*d3))/dm+0.5);
bmread(data,1,0,ist3*n2+ist2,ns,tr.data);
imoff=MIN(imoff,im-1);
{ register int it;
/* get the mute time for this
offset, apperture and velocity */
xindex(ns,ap,imoff*dm,&imt);
for(it=imt;it<ns;it++)
if(tr.data[it]!=0) {
mgd[imoff][it]+=tr.data[it];
mgdnz[imoff][it]+=1;
}
}
}
}
}
}
/* normalize the gather */
{ register int ix,it;
for(ix=0;ix<im;ix++)
for(it=0;it<ns;it++)
if(mgdnz[ix][it] > 1) mgd[ix][it] /=(float) mgdnz[ix][it];
}
memset( (void *) tr.data, (int) '\0',ns*FSIZE);
memset( (void *) mtnz, (int) '\0',ns*ISIZE);
/* do a knmo */
{ register int ix,it;
for(ix=0;ix<im;ix++) {
/* get the mute time for this
offset, apperture and velocity */
xindex(ns,ap,ix*dm,&imt);
knmo(mgd[ix],migt,ns,velfi,0,ix*dm,dt,imt,sphr);
/* stack the gather */
for(it=0;it<ns;it++) {
if(migt[it]!=0.0) {
tr.data[it] += migt[it];
mtnz[it]++;
}
/* tr.data[it] += mgd[ix][it]; */
}
}
}
{ register int it;
for(it=0;it<ns;it++)
if(mtnz[it]>1) tr.data[it] /=(float)mtnz[it];
}
/*Do the phase filtering before the trace is released*/
/* Load trace into rt (zero-padded) */
memcpy( (void *) rt, (const void *) tr.data, ns*FSIZE);
memset((void *) (rt + ns), (int) '\0', nzeros);
pfarc(1, nfft, rt, ct);
{ register int i;
for (i = 0; i < nf; ++i) ct[i] = cmul(ct[i], filt[i]);
}
pfacr(-1, nfft, ct, rt);
memcpy( (void *) tr.data, (const void *) rt, ns*FSIZE);
} /* end of dummy if */
/* spit out the gather */
efread(&tr, 1, HDRBYTES, headerfp);
puttr(&tr);
if(verbose) fprintf(stderr," %d %d\n",i2,i3);
} /* end of i2 loop */
} /* end of i3 loop */
/* This should be the last thing */
efclose(headerfp);
/* Free memory */
free2int(igtr);
free2float(mgd);
free2int(mgdnz);
free1int(apt);
bmfree(data);
bmfree(vel);
free1float(velfi);
free1float(velf);
free1float(ddt);
free1float(vdt);
free1float(ap);
free1int(mtnz);
free1float(migt);
free1float(rt);
free1complex(ct);
free1complex(filt);
free2((void **) dummyi);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
float phase; /* phase shift = phasefac*PI */
float power; /* phase shift = phasefac*PI */
register float *rt; /* real trace */
register complex *ct; /* complex transformed trace */
complex *filt; /* complex power */
int nt; /* number of points on input trace */
size_t ntsize; /* nt in bytes */
int ncdp; /* number of cdps specified */
int icdp; /* index into cdp array */
long oldoffset; /* offset of previous trace */
long oldcdp; /* cdp of previous trace */
int newsloth; /* if non-zero, new sloth function was computed */
int jcdp; /* index into cdp array */
float dt; /* sample spacing (secs) on input trace */
float tn; /* sample spacing (secs) on input trace */
float omega; /* circular frequency */
float domega; /* circular frequency spacing (from dt) */
int nfft; /* number of points in nfft */
int ntnmo; /* number of tnmos specified */
float *cdp; /* array[ncdp] of cdps */
float *vnmo; /* array[nvnmo] of vnmos */
float *ovvt; /* array[nvnmo] of vnmos */
int nvnmo; /* number of tnmos specified */
float *fnmo; /* array[ntnmo] of tnmos */
float **ovv; /* array[nf] of fnmos */
float doffs; /* offset */
float acdp; /* temporary used to sort cdp array */
float *aovv; /* temporary used to sort ovv array */
int invert; /* if non-zero, do invers DLMO */
int cm; /* if non-zero, the offset in cm */
int nf; /* number of frequencies (incl Nyq) */
int it; /* number of frequencies (incl Nyq) */
float onfft; /* 1 / nfft */
float v; /* velocity */
size_t nzeros; /* number of padded zeroes in bytes */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Set parameters */
power=0.0;
/* Get info from first trace*/
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
if (!getparfloat("dt", &dt)) dt = ((double) tr.dt)/1000000.0;
if (!dt) err("dt field is zero and not getparred");
ntsize = nt * FSIZE;
if (!getparint("invert",&invert)) invert = 0;
if (!getparint("cm",&cm)) cm = 0;
/* Set up for fft */
nfft = npfaro(nt, LOOKFAC * nt);
if (nfft >= SU_NFLTS || nfft >= PFA_MAX)
err("Padded nt=%d -- too big", nfft);
nf = nfft/2 + 1;
onfft = 1.0 / nfft;
nzeros = (nfft - nt) * FSIZE;
domega = TWOPI * onfft / dt;
/* get velocity functions, linearly interpolated in frequency */
ncdp = countparval("cdp");
if (ncdp>0) {
if (countparname("vnmo")!=ncdp)
err("a vnmo array must be specified for each cdp");
if (countparname("fnmo")!=ncdp)
err("a tnmo array must be specified for each cdp");
} else {
ncdp = 1;
if (countparname("vnmo")>1)
err("only one (or no) vnmo array must be specified");
if (countparname("fnmo")>1)
err("only one (or no) tnmo array must be specified");
}
cdp = ealloc1float(ncdp);
if (!getparfloat("cdp",cdp)) cdp[0] = tr.cdp;
ovv = ealloc2float(nf,ncdp);
for (icdp=0; icdp<ncdp; ++icdp) {
nvnmo = countnparval(icdp+1,"vnmo");
ntnmo = countnparval(icdp+1,"fnmo");
if (nvnmo!=ntnmo && !(ncdp==1 && nvnmo==1 && ntnmo==0))
err("number of vnmo and tnmo values must be equal");
if (nvnmo==0) nvnmo = 1;
if (ntnmo==0) ntnmo = nvnmo;
/* equal numbers of parameters vnmo, fnmo */
vnmo = ealloc1float(nvnmo);
fnmo = ealloc1float(nvnmo);
if (!getnparfloat(icdp+1,"vnmo",vnmo)) vnmo[0] = 400.0;
if (!getnparfloat(icdp+1,"fnmo",fnmo)) fnmo[0] = 0.0;
for (it=0; it<ntnmo; ++it)
fnmo[it]*=TWOPI;
for (it=1; it<ntnmo; ++it)
if (fnmo[it]<=fnmo[it-1])
err("tnmo values must increase monotonically");
for (it=0,tn=0; it<nf; ++it,tn+=domega) {
intlin(ntnmo,fnmo,vnmo,vnmo[0],vnmo[nvnmo-1],1,&tn,&v);
ovv[icdp][it] = 1.0/(v);
}
free1float(vnmo);
free1float(fnmo);
}
/* sort (by insertion) sloth and anis functions by increasing cdp */
for (jcdp=1; jcdp<ncdp; ++jcdp) {
acdp = cdp[jcdp];
aovv = ovv[jcdp];
for (icdp=jcdp-1; icdp>=0 && cdp[icdp]>acdp; --icdp) {
cdp[icdp+1] = cdp[icdp];
ovv[icdp+1] = ovv[icdp];
}
cdp[icdp+1] = acdp;
ovv[icdp+1] = aovv;
}
/* allocate workspace */
ovvt = ealloc1float(nf);
/* interpolate sloth and anis function for first trace */
interpovv(nf,ncdp,cdp,ovv,(float)tr.cdp,ovvt);
/* set old cdp and old offset for first trace */
oldcdp = tr.cdp;
oldoffset = tr.offset-1;
/* Allocate fft arrays */
rt = ealloc1float(nfft);
ct = ealloc1complex(nf);
filt = ealloc1complex(nf);
/* Loop over traces */
do {
/* if necessary, compute new sloth and anis function */
if (tr.cdp!=oldcdp && ncdp>1) {
interpovv(nt,ncdp,cdp,ovv,(float)tr.cdp,
ovvt);
newsloth = 1;
} else {
newsloth = 0;
}
/* if sloth and anis function or offset has changed */
if (newsloth || tr.offset!=oldoffset) {
doffs = (fabs)((float)(tr.offset));
if (cm==1) doffs/=100;
/* Load trace into rt (zero-padded) */
memcpy( (void *) rt, (const void *) tr.data, ntsize);
memset((void *) (rt + nt), (int) '\0', nzeros);
/* FFT */
pfarc(1, nfft, rt, ct);
/* Apply filter */
{ register int i;
for (i = 0; i < nf; ++i){
omega = i * domega;
if (power < 0 && i == 0) omega = FLT_MAX;
if (invert==0)
phase = -1.0*omega*ovvt[i]*doffs;
else
phase = 1.0*omega*ovvt[i]*doffs;
/* filt[i] = cmplx(cos(phase),sin(phase)); */
filt[i] = cwp_cexp(crmul(I,phase));
filt[i] = crmul(filt[i], onfft);
ct[i] = cmul(ct[i], filt[i]);
}
}
}
/* Invert */
pfacr(-1, nfft, ct, rt);
/* Load traces back in, recall filter had nfft factor */
{ register int i;
for (i = 0; i < nt; ++i) tr.data[i] = rt[i];
}
puttr(&tr);
} while (gettr(&tr));
return EXIT_SUCCESS;
}
int main (int argc, char **argv)
{
int nt; /* number of time samples */
int nz; /* number of migrated depth samples */
int nx,nxshot; /* number of midpoints,shotgathers, the folds in a shot
gather */
int flag=1; /*flag to use ft or meter as the unit*/
int dip=65; /*maximum dip angle to migrate*/
int iz,iw,ix,it,oldsx; /* loop counters*/
int ntfft; /* fft size*/
int nw; /* number of wave numbers */
int mytid,tids[NNTASKS],msgtype,rc,i;/*variable for PVM function*/
int nw1,task;
int lpad=9999,rpad=9999; /*zero-traces padded on left and right sides*/
float f1,f2,f3,f4; /*frequencies to build the Hamming window*/
int nf1,nf2,nf3,nf4; /*the index for above frequencies*/
int NTASKS=0; /*number of slave tasks to start*/
char cpu_name[NNTASKS][80]; /*strings to store the computers' name*/
int flag_cpu=0; /*flag to control if using NTASKS variable*/
float sx,gxmin,gxmax; /*location of geophone and receivers*/
int isx,nxo,ifx=0; /*index for geophone and receivers*/
int ix1,ix2,ix3,il,ir; /*dummy index*/
float *wl,*wtmp; /*pointers for the souce function*/
float Fmax=25; /*peak frequency to make the Ricker wavelet*/
int ntw,truenw; /*number of frequencies to be migrated*/
float dt=0.004,dz; /*time, depth sampling interval*/
float ft; /*first time sample*/
float dw; /*frequency sampling interval*/
float fw; /*first frequency*/
float dx; /*spatial sampling interval*/
float **p,**cresult,**result_tmp; /* input, output data*/
float **v; /*double pointer direct to velocity structure*/
complex *wlsp,**cp,**cq,**cq1; /*pointers for internal usage*/
char *vfile=""; /* name of file containing velocities */
char *cpufile=""; /* name of file containing CPU name */
FILE *vfp,*cpu_fp;
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(1);
/* get optional parameters */
if (!getparfloat("ft",&ft)) ft = 0.0;
if (!getparint("nz",&nz)) err("nz must be specified");
if (!getparfloat("dz",&dz)) err("dz must be specified");
if (!getparstring("vfile", &vfile)) err("vfile must be specified");
if (!getparint("nxo",&nxo)) err("nxo must be specified");
if (!getparint("nxshot",&nxshot)) err("nshot must be specified");
if (!getparfloat("Fmax",&Fmax)) err("Fmax must be specified");
if (!getparfloat("f1",&f1)) f1 = 10.0;
if (!getparfloat("f2",&f2)) f2 = 20.0;
if (!getparfloat("f3",&f3)) f3 = 40.0;
if (!getparfloat("f4",&f4)) f4 = 50.0;
if (!getparint("lpad",&lpad)) lpad=9999;
if (!getparint("rpad",&rpad)) rpad=9999;
if (!getparint("flag",&flag)) flag=1;
if (!getparint("dip",&dip)) dip=65;
if (getparstring("cpufile", &cpufile)){
cpu_fp=fopen(cpufile,"r");
NTASKS=0;
while(!feof(cpu_fp)){
fscanf(cpu_fp,"%s",cpu_name[NTASKS]);
NTASKS++;
}
NTASKS-=1;
flag_cpu=1;
}
else /*if cpufile not specified, the use NTASKS*/
if (!getparint("NTASKS",&NTASKS)) err("No CPUfile specified, NTASKS must be specified");
/*allocate space for the velocity profile*/
tshot=nxshot;
v=alloc2float(nxo,nz);
/*load velicoty file*/
vfp=efopen(vfile,"r");
efread(v[0],FSIZE,nz*nxo,vfp);
efclose(vfp);
/*PVM communication starts here*/
mytid=pvm_mytid(); /*get my pid*/
task=NTASKS;
warn("\n %d",task);
rc=0;
/*spawn slave processes here*/
if(!flag_cpu){
rc=pvm_spawn(child,NULL,PvmTaskDefault,"",task,tids);
}
else{
for(i=0;i<NTASKS;i++){
rc+=pvm_spawn(child,NULL,PvmTaskHost,cpu_name[i],1,&tids[i]);
}
}
/*show the pid of slaves if*/
for(i=0;i<NTASKS;i++){
if(tids[i]<0)warn("\n %d",tids[i]);
else warn("\nt%x\t",tids[i]);
}
/*if not all the slaves start, then quit*/
if(rc<NTASKS){ warn("error");pvm_exit();exit(1);}
/*broadcast the global parameters nxo,nz,dip to all slaves*/
pvm_initsend(PvmDataDefault);
rc=pvm_pkint(&nxo,1,1);
rc=pvm_pkint(&nz,1,1);
rc=pvm_pkint(&dip,1,1);
msgtype=PARA_MSGTYPE;
task=NTASKS;
rc=pvm_mcast(tids,task,msgtype);
/*broadcast the velocity profile to all slaves*/
pvm_initsend(PvmDataDefault);
rc=pvm_pkfloat(v[0],nxo*nz,1);
msgtype=VEL_MSGTYPE;
rc=pvm_mcast(tids,task,msgtype);
/*free the space for velocity profile*/
free2float(v);
/*loop over shot gathers begin here*/
loop:
/* get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
/* let user give dt and/or dx from command line */
if (!getparfloat("dt", &dt)) {
if (tr.dt) { /* is dt field set? */
dt = ((double) tr.dt)/1000000.0;
} else { /* dt not set, assume 4 ms */
dt = 0.004;
warn("tr.dt not set, assuming dt=0.004");
}
}
if (!getparfloat("dx",&dx)) {
if (tr.d2) { /* is d2 field set? */
dx = tr.d2;
} else {
dx = 1.0;
warn("tr.d2 not set, assuming d2=1.0");
}
}
sx=tr.sx;
isx=sx/dx;
gxmin=gxmax=tr.gx;
oldsx=sx;
/* determine frequency sampling interval*/
ntfft = npfar(nt);
nw = ntfft/2+1;
dw = 2.0*PI/(ntfft*dt);
/*compute the index of the frequency to be migrated*/
fw=2.0*PI*f1;
nf1=fw/dw+0.5;
fw=2.0*PI*f2;
nf2=fw/dw+0.5;
fw=2.0*PI*f3;
nf3=fw/dw+0.5;
fw=2.0*PI*f4;
nf4=fw/dw+0.5;
/*the number of frequency to migrated*/
truenw=nf4-nf1+1;
fw=0.0+nf1*dw;
warn("nf1=%d nf2=%d nf3=%d nf4=%d nw=%d",nf1,nf2,nf3,nf4,truenw);
fw=0.0;
/* allocate space */
wl=alloc1float(ntfft);
wlsp=alloc1complex(nw);
/*generate the Ricker wavelet*/
wtmp=ricker(Fmax,dt,&ntw);
for(it=0;it<ntfft;it++)
wl[it]=0.0;
for(it=0;it<ntw-12;it++)
wl[it]=wtmp[it+12];
free1float( wtmp);
/*Fourier transform the Ricker wavelet to frequency domain*/
pfarc(-1,ntfft,wl,wlsp);
/* allocate space */
p = alloc2float(ntfft,nxo);
cp = alloc2complex(nw,nxo);
for (ix=0; ix<nxo; ix++)
for (it=0; it<ntfft; it++)
p[ix][it] = 0.0;
/*read in a single shot gather*/
ix=tr.gx/dx;
memcpy( (void *) p[ix], (const void *) tr.data,nt*FSIZE);
nx = 0;
while(gettr(&tr)){
int igx;
if(tr.sx!=oldsx){ fseek(stdin,(long)(-240-nt*4),SEEK_CUR); break;}
igx=tr.gx/dx;
memcpy( (void *) p[igx], (const void *) tr.data,nt*FSIZE);
if(gxmin>tr.gx)gxmin=tr.gx;
if(gxmax<tr.gx)gxmax=tr.gx;
nx++;
oldsx=tr.sx;
}
warn("\nnx= %d",nx);
warn("sx %f , gxmin %f gxmax %f",sx,gxmin,gxmax);
/*transform the shot gather from time to frequency domain*/
pfa2rc(1,1,ntfft,nxo,p[0],cp[0]);
/*compute the most left and right index for the migrated section*/
ix1=sx/dx;
ix2=gxmin/dx;
ix3=gxmax/dx;
if(ix1>=ix3)ix3=ix1;
if(ix1<=ix2)ix2=ix1;
il=ix2;
ir=ix3;
ix2-=lpad;
ix3+=rpad;
if(ix2<0)ix2=0;
if(ix3>nxo-1)ix3=nxo-1;
/*the total traces to be migrated*/
nx=ix3-ix2+1;
/*allocate space*/
cq = alloc2complex(nx,nw);
cq1 = alloc2complex(nx,nw);
/*transpose the frequency domain data from data[ix][iw] to data[iw][ix] and
apply a Hamming at the same time*/
for (ix=0; ix<nx; ix++)
for (iw=0; iw<nw; iw++){
float tmpp=0.0,tmppp=0.0;
if(iw<nf1||iw>nf4)
cq[iw][ix]=cmplx(0.0,0.0);
else{
if(iw>=nf1&&iw<=nf2){tmpp=PI/(nf2-nf1);tmppp=tmpp*(iw-nf1)-PI;tmpp=0.54+0.46*cos(tmppp);
cq[iw][ix]=crmul(cp[ix+ix2][iw],tmpp);}
else{
if(iw>=nf3&&iw<=nf4){tmpp=PI/(nf4-nf3);tmppp=tmpp*(iw-nf3);tmpp=0.54+0.46*cos(tmppp);
cq[iw][ix]=crmul(cp[ix+ix2][iw],tmpp);}
else
{cq[iw][ix]=cp[ix+ix2][iw];}
}
}
cq[iw][ix]=cp[ix+ix2][iw];
cq1[iw][ix]=cmplx(0.0,0.0);
}
ix=sx/dx-ifx;
warn("ix %d",ix);
for(iw=0;iw<nw;iw++){
cq1[iw][ix-ix2]=wlsp[iw];
}
free2float(p);
free2complex(cp);
free1float(wl);
free1complex(wlsp);
/*if the horizontal spacing interval is in feet, convert it to meter*/
if(!flag)
dx*=0.3048;
/*start of the timing function*/
time(&t1);
/* send local parameters to all slaves*/
pvm_initsend(PvmDataDefault);
ix=15;
rc=pvm_pkint(&ix,1,1);
rc=pvm_pkint(&ntfft,1,1);
rc=pvm_pkint(&ix2,1,1);
rc=pvm_pkint(&ix3,1,1);
rc=pvm_pkint(&isx,1,1);
rc=pvm_pkint(&il,1,1);
rc=pvm_pkint(&ir,1,1);
rc=pvm_pkfloat(&dx,1,1);
rc=pvm_pkfloat(&dz,1,1);
rc=pvm_pkfloat(&dw,1,1);
rc=pvm_pkfloat(&dt,1,1);
msgtype=PARA_MSGTYPE;
task=NTASKS;
rc=pvm_mcast(tids,task,msgtype);
/* send all the frequency to slaves*/
count=NTASKS*5; /*count is the number of frequency components in a shot
gather*/
nw=truenw;
nw1=nw/(count);
if(nw1==0)nw1=1;
total=count=ceil(nw*1.0/nw1);
/* if it is the first shot gather, send equal data to all the slaves, then for
the following shot gathers, only send data when slave requests*/
if(nxshot==tshot){
for(i=0;i<NTASKS;i++){
float *tmpp;
float fw1;
int nww,byte,nwww;
pvm_initsend(PvmDataDefault);
nww=nf1+i*nw1;fw1=fw+nww*dw;
nwww=nw1;
byte=UnDone;
rc=pvm_pkint(&byte,1,1);
rc=pvm_pkfloat(&fw1,1,1);
rc=pvm_pkint(&nwww,1,1);
rc=pvm_pkfloat((float *)cq[nww],nx*nwww*2,1);
rc=pvm_pkfloat((float *)cq1[nww],nx*nwww*2,1);
msgtype=DATA_MSGTYPE;
pvm_send(tids[i],msgtype);
}
count-=NTASKS;
}
while(count){
int tid0,bufid;
float *tmpp;
float fw1;
int nww,byte,nwww;
int i;
i=total-count;
msgtype=COM_MSGTYPE;
bufid=pvm_recv(-1,msgtype);
rc=pvm_upkint(&tid0,1,1);
pvm_freebuf(bufid);
pvm_initsend(PvmDataDefault);
nww=nf1+i*nw1;fw1=fw+nww*dw;
if(i==total-1)nwww=nw-nw1*i;
else nwww=nw1;
byte=UnDone;
rc=pvm_pkint(&byte,1,1);
rc=pvm_pkfloat(&fw1,1,1);
rc=pvm_pkint(&nwww,1,1);
rc=pvm_pkfloat((float *)cq[nww],nx*nwww*2,1);
rc=pvm_pkfloat((float *)cq1[nww],nx*nwww*2,1);
msgtype=DATA_MSGTYPE;
pvm_send(tid0,msgtype);
count--;
}
ix=Done;
pvm_initsend(PvmDataDefault);
rc=pvm_pkint(&ix,1,1);
msgtype=DATA_MSGTYPE;
pvm_mcast(tids,task,msgtype);
free2complex(cq);
free2complex(cq1);
time(&t2);
warn("\n %d shot been finished in %f seconds, Ntask=%d",nxshot,difftime(t2,t1),NTASKS);
nxshot--;
if(nxshot)goto loop;
/*when all the shot gathers done, send signal to all slaves to request the
partial imaging*/
ix=FinalDone;
pvm_initsend(PvmDataDefault);
rc=pvm_pkint(&ix,1,1);
msgtype=PARA_MSGTYPE;
pvm_mcast(tids,task,msgtype);
/*allocate space for the final image*/
cresult = alloc2float(nz,nxo);
for(ix=0;ix<nxo;ix++)
for(iz=0;iz<nz;iz++)
{ cresult[ix][iz]=0.0;
}
result_tmp= alloc2float(nz,nxo);
/*receive partial image from all the slaves*/
msgtype=RESULT_MSGTYPE;
i=0;
while(i<NTASKS){
int bufid;
bufid=pvm_recv(-1,msgtype);
rc=pvm_upkfloat(result_tmp[0],nxo*nz,1);
pvm_freebuf(bufid);
for(ix=0;ix<nxo;ix++)
for(iz=0;iz<nz;iz++)
{
cresult[ix][iz]+=result_tmp[ix][iz];
}
i=i+1;
warn("\n i=%d been received",i);
}
/*send signal to all slaves to kill themselves*/
pvm_initsend(PvmDataDefault);
pvm_mcast(tids,task,COM_MSGTYPE);
/*output the final image*/
for(ix=0; ix<nxo; ix++){
tr.ns = nz ;
tr.dt = dz*1000000.0 ;
tr.d2 = dx;
tr.offset = 0;
tr.cdp = tr.tracl = ix;
memcpy( (void *) tr.data, (const void *) cresult[ix],nz*FSIZE);
puttr(&tr);
}
pvm_exit();
return EXIT_SUCCESS;
}
float modeling()
{
/* declaration of variables */
FILE *fp; /* to report results */
int iF, iF1, iR, offset, iT1, iT2, iS, iProc, i, k;
/* counters */
int wL; /* window length */
int die; /* die processor flag */
int FReceived; /* number of frequencies processed */
int apl_pid; /* PVM process id control */
int pid; /* process id */
int processControl; /* monitoring PVM start */
int FInfo[2]; /* frequency delimiters */
float wallcpu; /* wall clock time */
float oF; /* value of the objective function */
float residue; /* data residue */
float wdw; /* windowing purposes */
float *buffer, *bufferRCD; /* auxiliary buffers */
/* upgoing waves */
complex **dataS; /* synthethics in the frequency domain */
complex *bufferC; /* auxiliary buffer */
complex **freqPart; /* frequency arrays sent by the slaves */
/* Clean up log files */
CleanLog();
/* Reseting synchronization flags */
for (i = 0; i < nFreqPart; i++)
{
statusFreq[i][2] = 0;
}
/* allocating some memory */
dataS = alloc2complex(info->nF, info->nR);
buffer = alloc1float(info->nSamples);
bufferRCD = alloc1float(info->nSamples);
bufferC = alloc1complex(info->nSamples / 2 + 1);
freqPart = alloc2complex(info->nFreqProc, info->nR);
/* reseting */
for (iF = 0; iF < info->nSamples / 2 + 1; iF++)
bufferC[iF] = zeroC;
for (iS = 0; iS < info->nSamples; iS++)
{
buffer[iS] = 0; bufferRCD[iS] = 0;
}
/* DD
fprintf(stderr, "nF -> %d\n", info->nF);*/
fprintf(stderr, "Starting communication with PVM for modeling\n");
/* starting communication with PVM */
if ((apl_pid = pvm_mytid()) < 0)
{
pvm_perror("Error enrolling master process");
exit(-1);
}
processControl = CreateSlaves(processes, PROCESS_MODELING, nProc);
if (processControl != nProc)
{
fprintf(stderr,"Problem starting PVM daemons\n");
exit(-1);
}
/* converting to velocities */
if (IMPEDANCE)
{
for (i = 0; i < info->nL + 1; i++)
{
alpha[i] /= rho[i];
beta[i] /= rho[i];
}
}
/* Broadcasting all processes common information */
BroadINFO(info, 1, processes, nProc, GENERAL_INFORMATION);
/* sending all profiles */
BroadFloat(thick, info->nL + 1, processes, nProc, THICKNESS);
BroadFloat(rho, info->nL + 1, processes, nProc, DENSITY);
BroadFloat(alpha, info->nL + 1, processes, nProc, ALPHAS);
BroadFloat(qP, info->nL + 1, processes, nProc, QALPHA);
BroadFloat(beta, info->nL + 1, processes, nProc, BETAS);
BroadFloat(qS, info->nL + 1, processes, nProc, QBETA);
/* sending frequency partitions for each process */
for (iProc = 0; iProc < nProc; iProc++)
{
FInfo[0] = statusFreq[iProc][0];
FInfo[1] = statusFreq[iProc][1];
if (info->verbose)
fprintf(stderr,
"Master sending frequencies [%d, %d] out of %d to slave Modeling %d [id:%d]\n", FInfo[0], FInfo[1], info->nF, iProc, processes[iProc]);
procInfo[iProc][0] = FInfo[0];
procInfo[iProc][1] = FInfo[1];
SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS);
statusFreq[iProc][2] = 1;
}
/* waiting modelled frequencies */
/* master process will send more frequencies if there's more work to do */
/* measuring elapsed time */
wallcpu = walltime();
/* reseting frequency counter */
FReceived = 0;
while (FOREVER)
{
pid = RecvCplx(freqPart[0], info->nR * info->nFreqProc, -1,
FREQUENCY_PARTITION);
/* finding the frequency limits of this process */
/* DD
fprintf(stderr, "Master finding the frequency limits of this process\n");
*/
iProc = 0;
while (pid != processes[iProc])
iProc++;
/* DD
fprintf(stderr, "iProc %d pid %d\n", iProc, pid);*/
/* copying into proper place of the total frequency array */
for (iR = 0; iR < info->nR; iR++)
{
for (k = 0, i = procInfo[iProc][0]; i <= procInfo[iProc][1]; i++, k++)
{
dataS[iR][i - initF] = freqPart[iR][k];
}
}
/* summing frequencies that are done */
FReceived += procInfo[iProc][1] - procInfo[iProc][0] + 1;
if (info->verbose)
fprintf(stderr, "Master received %d frequencies, remaining %d\n",
FReceived, info->nF - FReceived);
/* defining new frequency limits */
i = 0;
while (i < nFreqPart && statusFreq[i][2])
i++;
/* DD
fprintf(stderr, "i %d nFreqPart %d\n", i, nFreqPart);*/
if (i < nFreqPart)
{
/* there is still more work to be done */
/* tell this process to not die */
die = 0;
SendInt(&die, 1, processes[iProc], DIE);
FInfo[0] = statusFreq[i][0];
FInfo[1] = statusFreq[i][1];
if (info->verbose)
fprintf(stderr, "Master sending frequencies [%d, %d] to slave %d\n", FInfo[0], FInfo[1], processes[iProc]);
procInfo[iProc][0] = FInfo[0];
procInfo[iProc][1] = FInfo[1];
SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS);
statusFreq[i][2] = 1;
}
else
{
/* tell this process to die since there is no more work to do */
if (info->verbose)
fprintf(stderr, "Master ''killing'' slave %d\n", processes[iProc]);
die = 1;
SendInt(&die, 1, processes[iProc], DIE);
}
/* a check to get out the loop */
if (FReceived >= info->nF) break;
}
/* quitting PVM */
EndOfMaster();
/* getting elapsed time */
wallcpu = walltime() - wallcpu;
fprintf(stderr, "Modeling wall clock time = %f seconds\n",
wallcpu);
/* back to impedances*/
if (IMPEDANCE)
{
for (i = 0; i < info->nL + 1; i++)
{
alpha[i] *= rho[i];
beta[i] *= rho[i];
}
}
/* computing the objective function for the time window */
for (oF = 0, residue = 0, iR = 0; iR < info->nR; iR++)
{
/* windowing as it was done to the input data */
iT1 = NINT(info->f1 / info->dF);
iT2 = NINT(info->f2 / info->dF);
wL = info->nF * PERC_WINDOW / 2;
wL = 2 * wL + 1;
for (iS = 0, iF = 0; iF < info->nSamples / 2 + 1; iF++)
{
if (iF < iT1 || iF >= iT2)
{
bufferC[iF] = cmplx(0, 0);
}
else if (iF - iT1 < (wL - 1) / 2)
{
wdw = .42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferC[iF].r = dataS[iR][iF - iT1].r * wdw;
bufferC[iF].i = dataS[iR][iF - iT1].i * wdw;
iS++;
}
else if (iF - iT1 >= info->nF - (wL - 1) / 2)
{
iS++;
wdw = .42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferC[iF].r = dataS[iR][iF - iT1].r * wdw;
bufferC[iF].i = dataS[iR][iF - iT1].i * wdw;
}
else
{
bufferC[iF] = dataS[iR][iF - iT1];
}
}
/* going to time domain */
/* DD
fprintf(stderr, "going to time domain \n");*/
pfacr(1, info->nSamples, bufferC, buffer);
/* muting ? */
if (MUTE)
{
for (iS = 0; iS <= NINT(t1Mute[iR] / dt); iS++)
{
buffer[iS] = 0;
}
}
/* and computing data misfit and likelihood function */
iS = NINT(t1 / dt);
for (iT1 = 0; iT1 < nDM; iT1++)
{
bufferRCD[iT1 + iS] = 0;
for (offset = iT1, iT2 = 0; iT2 < nDM; iT2++)
{
bufferRCD[iT1 + iS] +=
(buffer[iT2 + iS] - dataObs[iR][iT2]) * CD[offset];
offset += MAX(SGN0(iT1 - iT2) * (nDM - 1 - iT2), 1);
}
oF += (buffer[iT1 + iS] - dataObs[iR][iT1]) * bufferRCD[iT1 + iS];
residue += (buffer[iT1 + iS] - dataObs[iR][iT1]) *
(buffer[iT1 + iS] - dataObs[iR][iT1]);
/* DD
fprintf(stdout, "%d %f %f %f %f %f %d %f %f\n",
nTotalSamples, oF, dt, auxm1,
info->tau, residue, iT1, buffer[iT1],
dataObs[iR][iT1 - NINT(t1 / dt)]); */
}
/* windowing bufferRCD */
iT1 = NINT(t1 / dt);
iT2 = NINT(t2 / dt);
wL = nDM * PERC_WINDOW / 2;
wL = 2 * wL + 1;
for (iS = 0, iF = 0; iF < info->nSamples; iF++)
{
if (iF < iT1 || iF >= iT2)
{
bufferRCD[iF] = 0;
}
else if (iF - iT1 < (wL - 1) / 2)
{
wdw =
.42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferRCD[iF] *= wdw;
iS++;
}
else if (iF - iT1 >= nDM - (wL - 1) / 2)
{
iS++;
wdw =
.42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferRCD[iF] *= wdw;
}
}
/* going back to Fourier domain */
pfarc(-1, info->nSamples, bufferRCD, bufferC);
for (iF1 = 0, iF = NINT(info->f1 / info->dF);
iF <= NINT(info->f2 / info->dF); iF++, iF1++)
{
resCD[iR][iF1] = bufferC[iF];
}
}
/* considering the .5 factor of the exponent of the Gaussian */
/* and normalizing the likelihood by the number of samples */
oF /= (2 * nTotalSamples);
/* freeing some memory */
/* allocating some memory */
free2complex(dataS);
free1float(buffer);
free1float(bufferRCD);
free1complex(bufferC);
free2complex(freqPart);
/* considering the regularizaton or model covariance term */
if (PRIOR)
{
auxm1 = 1. / (float) (numberPar * limRange); /* normalization */
for (auxm2 = 0, iF = 0; iF < limRange; iF++)
{
for (offset = iF, iF1 = 0; iF1 < limRange; iF1++)
{
if (vpFrechet)
{
auxm2 += (alpha[iF + lim[0]] - alphaMean[iF + lim[0]]) *
CMvP[offset] * auxm1 *
(alpha[iF1 + lim[0]] - alphaMean[iF1 + lim[0]]);
}
if (vsFrechet)
{
auxm2 += (beta[iF + lim[0]] - betaMean[iF + lim[0]]) *
CMvS[offset] * auxm1 *
(beta[iF1 + lim[0]] - betaMean[iF1 + lim[0]]);
}
if (rhoFrechet)
{
auxm2 += (rho[iF + lim[0]] - rhoMean[iF + lim[0]]) *
CMrho[offset] * auxm1 *
(rho[iF1 + lim[0]] - rhoMean[iF1 + lim[0]]);
}
offset += MAX(SGN0(iF - iF1) * (limRange - 1 - iF1), 1);
}
}
}
/* getting normalization factor */
fp = fopen("report", "a");
fprintf(fp,"-----------------------\n");
if (modCount == 0)
{
oFNorm = oF;
fprintf(fp,">> Normalization constant for objective function: %f <<\n",
oFNorm);
}
/* normalizing residue */
residue /= (nTotalSamples);
if (!DATACOV && noiseVar == 0) noiseVar = residue / 10.;
if (PRIOR)
{
fprintf(fp,
"residue at iteration [%d] : Data residue variance %f , Noise variance %f , Likelihood %f , Prior %f\n",
modCount, residue, noiseVar, oF / oFNorm, auxm2 / oFNorm);
}
else
{
fprintf(fp,"residue at iteration [%d] : Data residue variance %f , Noise variance %f , Likelihood %f , No Prior\n", modCount, residue, noiseVar, oF / oFNorm);
}
/* checking if we reached noise variance with the data residue */
if (residue / noiseVar <= 1)
{
/* DATA IS FIT, stop the procedure */
fprintf(fp, "[][][][][][][][][][][][][][][][][][][][]\n");
fprintf(fp, "DATA WAS FIT UP TO 1 VARIANCE!\n");
fprintf(fp, "[][][][][][][][][][][][][][][][][][][][]\n");
exit(0);
}
/* adding Likelihood and Prior */
if (PRIOR) oF += auxm2 / 2;
fprintf(fp,"TOTAL residue at iteration [%d] : %f\n",
modCount, oF / oFNorm);
fprintf(fp,"-----------------------\n");
fclose(fp);
/* returning objective function value */
return(oF / oFNorm);
}
int
main(int argc, char **argv)
{
float *rt=NULL; /* real trace */
float *amp=NULL; /* amplitude spectra */
float *ph=NULL; /* phase */
register complex *ct=NULL; /* complex time trace */
int nt; /* number of points on input trace */
int nfft; /* transform length */
int nf; /* number of frequencies in transform */
float dt; /* sampling interval in secs */
float d1; /* output sample interval in Hz */
int count=0; /* counter */
/* linear phase function */
float a; /* bias (intercept) of new phase */
float b; /* slope of linear phase function */
float c; /* new phase value */
float onfft; /* 1/nfft */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
/* get parameters */
/* dt is used only to set output header value d1 */
if (!getparfloat("dt", &dt)) dt = ((double) tr.dt)/1000000.0;
if (!dt) {
dt = .004;
warn("dt not set, assumed to be .002");
}
/* linear phase paramter values */
if (!getparfloat("a", &a)) a = 0;
if (!getparfloat("b", &b)) b = 180/PI;
if (!getparfloat("c", &c)) c = 0.0;
a *= PI/180.0;
b *= PI/180.0;
/* Set up pfa fft */
nfft = npfaro(nt, LOOKFAC * nt);
if (nfft >= SU_NFLTS || nfft >= PFA_MAX)
err("Padded nt=%d--too big", nfft);
d1 = 1.0/(nfft*dt);
nf = nfft/2 + 1;
onfft = 1.0/nfft;
checkpars();
/* Allocate space */
rt = ealloc1float(nfft);
ct = ealloc1complex(nf);
amp = ealloc1float(nf);
ph = ealloc1float(nf);
/* Main loop over traces */
count=0;
do {
register int i;
/* Load trace into rt (zero-padded) */
memcpy((void *) rt, (const void *) &tr.data, nt*FSIZE);
memset((void *) (rt + nt), (int) '\0', (nfft-nt)*FSIZE);
/* FFT */
pfarc(1, nfft, rt, ct);
for (i = 0; i < nf; ++i) {
amp[i] = AMPSP(ct[i]);
ph[i] = a+b*atan2(ct[i].i,ct[i].r)+c*i;
}
for (i = 0; i < nf; ++i) {
ct[i].r = amp[i]*cos(ph[i]);
ct[i].i = amp[i]*sin(ph[i]);
}
pfacr(-1,nfft,ct,rt);
for (i = 0; i < nt; ++i) rt[i]*=onfft;
memcpy((void *) tr.data, (const void *) rt, nt*FSIZE);
puttr(&tr);
} while (gettr(&tr));
return(CWP_Exit());
}
void roughint(int *zp, int minx, int maxx, float dz, float *interface, float ampl, float beta, float seed)
{
int j, i, ndeltx, optn;
long idum;
float *fract;
float dk, mean, std;
complex *fracc, *fracc2;
ndeltx = maxx - minx + 1;
optn = npfar(npfa(ndeltx));
fract = (float *)malloc(optn*sizeof(float));
fracc = (complex *)malloc((optn/2+1)*sizeof(complex));
fracc2 = (complex *)malloc(optn*sizeof(complex));
/*
srandom(seed);
fact = 1.0/(float)pow(2.0, 31.0);
for (j = 0; j < optn; j++) fract[j] = (float)random()*fact;
*/
idum = (long) seed;
srand48(idum);
for (j = 0; j < optn; j++)
fract[j] = (float)drand48();
pfarc(-1, optn, fract, fracc);
dk = 1.0/(float)optn;
for (j = 1; j < optn/2+1; j++) {
fracc2[j].r = fracc[j].r*pow(j*dk, -beta/2.0);
fracc2[j].i = fracc[j].i*pow(j*dk, -beta/2.0);
}
for (j = optn/2+2; j < optn; j++) {
fracc2[j].r = fracc[optn-j].r;
fracc2[j].i = -1.0*fracc[optn-j].i;
}
fracc2[0].r = 0.0;
fracc2[0].i = 0.0;
pfacc(1, optn, fracc2);
for (j = 0; j < optn; j++) fract[j] = fracc2[j].r;
statics(fract, optn, &mean, &std);
for (j = 0; j < optn; j++) fract[j] -= mean;
dk = ampl/(2*std);
for (j = 0; j < optn; j++) fract[j] *= dk;
j = 0;
for (i = minx; i < maxx; i++) {
interface[i] += fract[j];
zp[i] = NINT(interface[i]/dz);
j++;
if (SGN(zp[i]) < 0)
zp[i] = 0;
}
free(fract);
free(fracc);
free(fracc2);
return;
}
main(int argc, char **argv)
{
register float *rt; /* real trace */
register complex *ct; /* complex transformed trace */
float *filter; /* filter array */
float f1; /* left lower corner frequency */
float f2; /* left upper corner frequency */
float f4; /* right lower corner frequency */
float f3; /* right upper corner frequency */
int if1,if2,if3,if4; /* integerizations of f1,f2,f3,f4 */
float dt; /* sample spacing */
float nyq; /* nyquist frequency */
int nt; /* number of points on input trace */
int nfft; /* number of points for fft trace */
int nf; /* number of frequencies (incl Nyq) */
int nfm1; /* nf-1 */
float onfft; /* reciprocal of nfft */
float df; /* frequency spacing (from dt) */
/* Initialize */
initargs(argc, argv);
askdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
if (tr.trid && tr.trid != TREAL)
err("input is not seismic data, trid=%d", tr.trid);
nt = tr.ns;
if (!getparfloat("dt", &dt)) dt = tr.dt/1000000.0;
if (!dt) err("dt field is zero and not getparred");
nyq = 0.5/dt;
/* Set up FFT parameters */
nfft = npfaro(nt, LOOKFAC * nt);
if (nfft >= MIN(SU_NFLTS, PFA_MAX))
err("Padded nt=%d -- too big", nfft);
nf = nfft/2 + 1;
nfm1 = nf - 1;
onfft = 1.0 / nfft;
/* Get corner frequencies */
if (!getparfloat("f1", &f1)) f1 = FRAC1 * nyq;
if (!getparfloat("f2", &f2)) f2 = FRAC2 * nyq;
if (!getparfloat("f3", &f3)) f3 = FRAC3 * nyq;
if (!getparfloat("f4", &f4)) f4 = FRAC4 * nyq;
if (f1 < 0.0 || f1 > f2 || f2 >= f3 || f3 > f4)
err("Bad filter parameters");
/* Allocate fft arrays */
rt = ealloc1float(nfft);
ct = ealloc1complex(nf);
filter = ealloc1float(nf);
/* Compute integer frequencies */
df = onfft / dt;
if1 = NINT(f1/df);
if2 = NINT(f2/df);
if3 = NINT(f3/df);
if (if3 > nfm1) if3 = nfm1;
if4 = NINT(f4/df);
if (if4 > nfm1) if4 = nfm1;
/* Make filter with scale for inverse transform */
{ register int i;
register float c = PIBY2 / (if2 - if1 + 2);
for (i = if1; i <= if2; ++i) {
register float s = sin(c*(i - if1 + 1));
filter[i] = s * s * onfft;
}
}
{ register int i;
register float c = PIBY2 / (if4 - if3 + 2);
for (i = if3; i <= if4; ++i) {
register float s = sin(c*(if4 - i + 1));
filter[i] = s * s * onfft;
}
}
{ register int i;
for (i = if2 + 1; i < if3; ++i) filter[i] = onfft;
for (i = 0; i < if1; ++i) filter[i] = 0.0;
for (i = if4 + 1; i < nf; ++i) filter[i] = 0.0;
}
/* Main loop over traces */
do {
register int i;
/* Load trace into rt (zero-padded) */
memcpy(rt, tr.data, nt*FSIZE);
bzero(rt + nt, (nfft-nt)*FSIZE);
/* FFT, filter, inverse FFT */
pfarc(1, nfft, rt, ct);
for (i = 0; i < nf; ++i) ct[i] = crmul(ct[i], filter[i]);
pfacr(-1, nfft, ct, rt);
/* Load traces back in, recall filter had nfft factor */
for (i = 0; i < nt; ++i) tr.data[i] = rt[i];
puttr(&tr);
} while (gettr(&tr));
return EXIT_SUCCESS;
}
int main( int argc, char *argv[] )
{
cwp_String key; /* header key word from segy.h */
cwp_String type; /* ... its type */
Value val;
segy **rec_o; /* trace header+data matrix */
int first=0; /* true when we passed the first gather */
int ng=0;
float dt;
int nt;
int ntr;
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 *ct; /* complex trace */
complex **fd; /* frequency domain data */
float **cc; /* correlation coefficinet matrix */
float padd;
float cch;
float ccl;
/* Initialize */
initargs(argc, argv);
requestdoc(1);
if (!getparstring("key", &key)) key = "ep";
if (!getparfloat("padd", &padd)) padd = 25.0;
padd = 1.0+padd/100.0;
if (!getparfloat("cch", &cch)) cch = 1.0;
if (!getparfloat("ccl", &ccl)) ccl = 0.3;
/* get the first record */
rec_o = get_gather(&key,&type,&val,&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;
rt = ealloc1float(nfft);
do {
ng++;
fd = ealloc2complex(nf,ntr);
cc = ealloc2float(nf,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]);
}
}
/* Compute correlation coefficients */
{ unsigned int itr,ifr;
for(itr=0;itr<ntr-1;itr++) {
for(ifr=0;ifr<nf-1;ifr++) {
cc[itr][ifr] = cos(PHSSP(fd[itr][ifr])-PHSSP(fd[itr+1][ifr]));
}
}
}
/* Filter */
{ unsigned int itr,ifr;
for(itr=0;itr<ntr-1;itr++) {
for(ifr=0;ifr<nf-1;ifr++) {
if(cc[itr][ifr]> cch || cc[itr][ifr]<ccl) {
fd[itr][ifr].r = 0.0;
fd[itr][ifr].i = 0.0;
}
}
}
}
{ unsigned int itr,it;
for(itr=0;itr<ntr;itr++) {
pfacr(-1, nfft, fd[itr], rt);
for(it=0;it<nt;it++)
(*rec_o[itr]).data[it]=rt[it]*snfft;
}
}
free2complex(fd);
free2float(cc);
rec_o = put_gather(rec_o,&nt,&ntr);
rec_o = get_gather(&key,&type,&val,&nt,&ntr,&dt,&first);
fprintf(stderr," %d %d\n",ng,ntr);
} while(ntr);
free1float(rt);
warn("Number of gathers %10d\n",ng);
return EXIT_SUCCESS;
}
/**************** end self doc ********************************/
static void cvstack(VND *vnda, VND *vnd, int icmp, int noff, float *off,
float *mute, int lmute, int nv, float *p2,
float dt, float dtout);
static void vget( float a, float b, float e, float d,
float theta, float *vel);
VND *ptabledmo(int nv, float *v, float etamin, float deta, int neta,
float d, float vsvp, int np, float dp, float dp2, char *file);
VND *ptablemig(int nv, float *v, float etamin, float deta,
int neta, float d, float vsvp, int np, char *file);
static void taper (int lxtaper, int lbtaper,
int nx, int ix, int nt, float *trace);
segy tr; /* input and output SEGY data */
FILE *fpl; /* file pointer for print listing */
int main(int argc, char **argv)
{
VND *vnd=NULL; /* big file holding data, all cmps, all etas, all velocities */
VND *vnda=NULL; /* holds one input cmp gather */
VND *vndb=NULL; /* holds (w,v) for one k component */
VND *vndvnmo=NULL; /* holds (vnmo,p) table for ti dmo */
VND *vndvphase=NULL; /* holds (vphase,p) table for ti Stolt migration */
long N[2]; /* holds number of values in each dimension for VND opens */
long key[2]; /* holds key in each dimension for VND i/o */
char **dir=NULL; /* could hold list of directories where to put VND temp files */
char *file; /* root name for temporary files */
char *printfile; /* name of file for printout */
complex *crt;
complex *ctemp;
complex czero;
float *rt;
char *ccrt;
char *fname;
float etamin; /* minimum eta scan to compute */
float etamax; /* maximum eta scan to compute */
float deta; /* increment in eta to compute for eta scan */
float dx; /* cmp spatial sampling interval */
float dk; /* wavenumber increment */
float dv; /* velocity increment */
float vmin; /* minimum output velocity */
float vmax; /* maximum output velocity */
float dt; /* input sample rate in seconds */
float dtout; /* output sample rate in seconds */
float *mute; /* array of mute times for this cmp */
float *off; /* array of offsets for this cmp */
float *v; /* array of output velocities */
float *p2stack; /* array of stacking 1/(v*v) */
float *rindex; /* array of interpolation indices */
float dp2=0.0; /* increment in slowness squared for input cvstacks */
float scale; /* used for trace scale factor */
float p; /* horizontal slowness */
float p2; /* p*p */
float v2; /* velocity squared */
float ak; /* horizontal wavenumber */
float dw; /* angular frequency increment */
float *w; /* array holding w values for Fowler */
float factor; /* scale factor */
float d; /* Thomsen's delta */
float vsvp; /* vs/vp ratio */
float dp; /* increment of slowness values in vndvnmo table */
float rp; /* real valued index in p */
float wgt; /* weight for linear interpolation */
float fmax; /* maximum frequency to use for antialias mute */
float salias; /* fraction of frequencies to be within sloth antialias limit */
float dpm; /* slowness increment in TI migration table */
float fw; /* first w in Stolt data table */
float vminstack;/* only used if reading precomputed cvstacks, minimum stacking vel */
int neta; /* number of eta scans to compute */
int ichoose; /* defines type of processing to do */
int ncmps; /* number of input and output cmps */
int nv; /* number of output velocity panels to generate */
int nvstack; /* number of cvstack panels to generate */
int ntpad; /* number of time samples to padd to avoid wraparound */
int nxpad; /* number of traces to padd to avoid wraparound */
int lmute; /* number of samples to taper mute */
int lbtaper; /* length of bottom time taper in ms */
int lstaper; /* length of side taper in traces */
int mxfold; /* maximum allowed number of input offsets/cmp */
int icmp; /* cmp index */
int ntfft; /* length of temporal fft for Fowler */
int ntffts; /* length of temporal fft for Stolt */
int nxfft; /* length of spatial fft */
int ntfftny; /* count of freq to nyquist */
int nxfftny; /* count of wavenumbers to nyquist */
int nmax; /* used to compute max number of samples for array allocation */
int oldcmp; /* current cdp header value */
int noff; /* number of offsets */
int k; /* wavenumber index */
int iwmin; /* minimum freq index */
int TI; /* 0 for isotropic, 1 for transversely isotropic */
long it; /* time index */
long iw; /* index for angular frequency */
long nt; /* number of input time samples */
long ntout; /* number of output time samples */
long iv; /* velocity index */
long ip; /* slowness index */
long ieta;
int nonhyp; /* flag equals 1 if do mute to avoid non-hyperbolic events */
int getcvstacks;/* flag equals 1 if input cvstacks precomputed */
int ngroup; /* number of traces per vel anal group */
int ndir; /* number of user specified directories for temp files */
/******************************************************************************/
/* input parameters, allocate buffers, and define reusable constants */
/******************************************************************************/
initargs(argc, argv);
requestdoc(1);
/* get first trace and extract critical info from header */
if(!gettr(&tr)) err("Can't get first trace \n");
nt=tr.ns;
dt=0.000001*tr.dt;
oldcmp=tr.cdp;
if (!getparstring("printfile",&printfile)) printfile=NULL;
if (printfile==NULL) {
fpl=stderr;
}else{
fpl=fopen(printfile,"w");
}
if (!getparfloat("salias",&salias)) salias=0.8;
if(salias>1.0) salias=1.0;
if (!getparfloat("dtout",&dtout)) dtout=1.5*dt;
ntout=1+nt*dt/dtout;
if (!getparint("getcvstacks",&getcvstacks)) getcvstacks=0;
if(getcvstacks) {
dtout=dt;
ntout=nt;
}
fmax=salias*0.5/dtout;
fprintf(fpl,"sutifowler: ntin=%ld dtin=%f\n",nt,dt);
fprintf(fpl,"sutifowler: ntout=%ld dtout=%f\n",ntout,dtout);
if (!getparstring("file",&file)) file="sutifowler";
if (!getparfloat("dx",&dx)) dx=25.;
if (!getparfloat("vmin",&vmin)) vmin=1500.;
if (!getparfloat("vmax",&vmax)) vmax=8000.;
if (!getparfloat("vminstack",&vminstack)) vminstack=vmin;
if (!getparfloat("d",&d)) d=0.0;
if (!getparfloat("etamin",&etamin)) etamin=0.0;
if (!getparfloat("etamax",&etamax)) etamax=0.5;
if (!getparfloat("vsvp",&vsvp)) vsvp=0.5;
if (!getparint("neta", &neta)) neta = 1;
if (fabs(etamax-etamin)<1.0e-7) neta = 1;
if (neta < 1) neta = 1;
if (!getparint("choose", &ichoose)) ichoose = 1;
if (!getparint("ncdps", &ncmps)) err("sutifowler: must enter ncdps");
if (!getparint("nv", &nv)) nv = 75;
if (!getparint("nvstack", &nvstack)) nvstack = 180;
if (!getparint("ntpad", &ntpad)) ntpad = 0.1*ntout;
if (!getparint("nxpad", &nxpad)) nxpad = 0;
if (!getparint("lmute", &lmute)) lmute = 24;
lmute=1 + 0.001*lmute/dtout;
if (!getparint("lbtaper", &lbtaper)) lbtaper = 0;
if (!getparint("lstaper", &lstaper)) lstaper = 0;
if (!getparint("mxfold", &mxfold)) mxfold = 120;
if (!getparint("nonhyp",&nonhyp)) nonhyp=1.;
if (!getparint("ngroup", &ngroup)) ngroup = 20;
ndir = countparname("p");
if(ndir==0) {
ndir=-1;
}else{
dir = (char **)VNDemalloc(ndir*sizeof(char *),"dir");
for(k=0;k<ndir;k++) {
it=getnparstring(k+1,"p",&dir[k]);
}
}
lbtaper=lbtaper/(1000.*dt);
TI=0;
if(fabs(d)>0. || fabs(etamin)>0 || neta>1 ) TI=1;
if(TI) fprintf(fpl,"sutifowler: operation in TI mode\n");
deta = 0.;
if(neta>1) deta=(etamax-etamin)/(neta-1);
dp=1./(vmin*(NP-5));
if(TI) dp=dp*sqrt(1.+2.*fabs(etamin));
if(ichoose>2) nvstack=nv;
if(ichoose==1 || ichoose==2 || ichoose==3) {
ntfft=ntout+ntpad;
}else{
ntfft=1;
}
if(ichoose==1 || ichoose==3) {
ntffts=2*ntout/0.6;
}else{
ntffts=1;
}
ntfft=npfao(ntfft,2*ntfft);
ntffts=npfao(ntffts,2*ntffts);
dw=2.*PI/(ntfft*dtout);
nxfft=npfar(ncmps+nxpad);
dk=2.*PI/(nxfft*dx);
fprintf(fpl,"sutifowler: ntfft=%d ntffts=%d nxfft=%d\n",ntfft,ntffts,nxfft);
czero.r=czero.i=0.;
scale=1.;
if(ichoose<5) scale=1./(nxfft);
if(ichoose==1 || ichoose==2 ) scale*=1./ntfft;
if(ichoose==1 || ichoose==3 ) scale*=1./ntffts;
nxfftny = nxfft/2 + 1;
ntfftny = ntfft/2 + 1;
nmax = nxfftny;
if(ntfft > nmax) nmax=ntfft;
if((NP/2+1)>nmax) nmax=(NP/2+1);
if(nvstack>nmax) nmax=nvstack;
if(nv*neta>nmax) nmax=nv*neta;
ctemp = (complex *)VNDemalloc(nmax*sizeof(complex),"allocating ctemp");
rindex=(float *)VNDemalloc(nmax*sizeof(float),"allocating rindex");
if(ntffts > nmax) nmax=ntffts;
crt = (complex *)VNDemalloc(nmax*sizeof(complex),"allocating crt");
rt = (float *)crt;
ccrt = (char *)crt;
fprintf(fpl,"sutifowler: nv=%d nvstack=%d\n",nv,nvstack);
v=(float *)VNDemalloc(nv*sizeof(float),"allocating v");
p2stack=(float *)VNDemalloc(nvstack*sizeof(float),"allocating p2stack");
mute=(float *)VNDemalloc(mxfold*sizeof(float),"allocating mute");
off=(float *)VNDemalloc(mxfold*sizeof(float),"allocating off");
fprintf(fpl,"sutifowler: allocating and filling w array\n");
w=(float *)VNDemalloc(ntfft*sizeof(float),"allocating w");
for(iw=0;iw<ntfft;iw++) {
if(iw<ntfftny){
w[iw]=iw*dw;
}else{
w[iw]=(iw-ntfft)*dw;
}
if(iw==0) w[0]=0.1*dw; /* fudge for dc component */
}
/******************************************************************************/
fprintf(fpl,"sutifowler: building function for stacking velocity analysis\n");
/******************************************************************************/
dv=(vmax-vmin)/MAX((nv-1),1);
for(iv=0;iv<nv;iv++) v[iv]=vmin+iv*dv;
if(ichoose>=3){
for(iv=0;iv<nvstack;iv++) {
p2stack[iv]=1./(v[iv]*v[iv]);
fprintf(fpl," stacking velocity %ld %f\n",iv,v[iv]);
}
}else{
if(nvstack<6) err("sutifowler: nvstack must be 6 or more");
dp2 = 1./(vminstack*vminstack*(nvstack-5));
for(iv=0;iv<nvstack;iv++) {
p2stack[iv]=iv*dp2;
if(iv>0) {
factor=1./sqrt(p2stack[iv]);
fprintf(fpl," stacking velocity %ld %f\n",iv,factor);
}else{
fprintf(fpl," stacking velocity %ld infinity\n",iv);
}
}
}
/******************************************************************************/
fprintf(fpl,"sutifowler: Opening and zeroing large block matrix disk file\n");
fprintf(fpl," This can take a while, but all is fruitless if the \n");
fprintf(fpl," necessary disk space is not there...\n");
/******************************************************************************/
N[0]=nxfft+2;
N[1]=ntout*MAX(nv*neta,nvstack);
fname=VNDtempname(file);
vnd = VNDop(2,0,2,N,1,sizeof(float),fname,ndir,dir,1);
VNDfree(fname,"main: freeing fname 1");
fprintf(fpl,"sutifowler: large file RAM mem buf = %ld bytes\n",
vnd->NumBytesMemBuf);
fprintf(fpl,"sutifowler: large file disk area = %ld bytes\n",
vnd->NumBytesPerBlock*vnd->NumBlocksPerPanel*vnd->NumPanels);
if(getcvstacks) {
/******************************************************************************/
fprintf(fpl,"sutifowler: reading input cvstacks\n");
/******************************************************************************/
for(icmp=0;icmp<ncmps;icmp++) {
key[0]=icmp;
key[1]=0;
for(iv=0;iv<nvstack;iv++) {
VNDrw('w',0,vnd,1,key,0,
(char *) tr.data,iv*ntout,1,ntout,
1,"writing cvstacks to disk");
if( !gettr(&tr) ) {
if(icmp==ncmps-1 && iv==nvstack-1 ) {
/* all ok, read all the input data */
}else{
err("sutifowler: error reading input cvstacks");
}
}
}
}
goto xffts;
}
/******************************************************************************/
fprintf(fpl,
"sutifowler: beginning constant velocity stacks of the input cmp gathers\n");
/******************************************************************************/
fname=VNDtempname(file);
vnda = V2Dop(2,1000000,sizeof(float),fname,nt,mxfold);
VNDfree(fname,"main: freeing fname 2");
fprintf(fpl,"sutifowler: cmp gather RAM mem buf = %ld bytes\n",
vnda->NumBytesMemBuf);
icmp=0;
noff=0;
do {
if(tr.cdp!=oldcmp) {
cvstack(vnda,vnd,icmp,noff,off,mute,lmute,
nvstack,p2stack,dt,dtout);
icmp++;
if(icmp==ncmps) {
fprintf(fpl,"sutifowler: more input cdps than ncdps parameter\n");
fprintf(fpl," Will only process ncdps gathers.\n");
goto done_with_input;
}
oldcmp=tr.cdp;
noff=0;
}
if(lbtaper>0 || lstaper>0) taper (lstaper,lbtaper,ncmps,icmp,nt,tr.data);
factor=scale;
for(it=0;it<nt;it++) tr.data[it]*=factor;
V2Dw0(vnda,noff,(char *)tr.data,1);
off[noff]=tr.offset;
if(ichoose==1 || ichoose==2) {
mute[noff]=fmax*off[noff]*off[noff]*dp2;
}else{
mute[noff]=0.;
}
if(nonhyp) mute[noff]=MAX(mute[noff],2*off[noff]/vmin);
noff++;
if(noff>mxfold) err("tifowler: input cdp has more traces than mxfold");
} while ( gettr(&tr) );
cvstack(vnda,vnd,icmp,noff,off,mute,lmute,
nvstack,p2stack,dt,dtout);
icmp++;
done_with_input:
ncmps=icmp;
fprintf(fpl,"sutifowler: read and stacked %d cmp gathers\n",ncmps);
VNDcl(vnda,1);
xffts:
VNDflush(vnd);
if(ichoose<5){
/******************************************************************************/
fprintf(fpl,"sutifowler: doing forward x -> k spatial fft's\n");
/******************************************************************************/
for(it=0;it<(ntout*nvstack);it++) {
V2Dr0(vnd,it,ccrt,21);
for(k=ncmps;k<nxfft+2;k++) rt[k]=0.;
pfarc(1,nxfft,rt,crt);
V2Dw0(vnd,it,ccrt,22);
}
VNDr2c(vnd);
}
if(ichoose<=3) {
fprintf(fpl,"sutifowler: looping over k\n");
if(TI && (ichoose==1 || ichoose==2)) { /* build ti vnmo(p) table */
vndvnmo=ptabledmo(nv,v,etamin,deta,neta,d,vsvp,NP,dp,dp2,file);
fprintf(fpl,"sutifowler: dmo index(p) RAM mem buf = %ld bytes\n",
vndvnmo->NumBytesMemBuf);
}
if(TI && (ichoose==1 || ichoose==3)){ /* build ti vphase(p) table */
vndvphase=ptablemig(nv,v,etamin,deta,neta,d,vsvp,NP,file);
fprintf(fpl,"sutifowler: migration scaler(p) RAM mem buf = %ld bytes\n",
vndvphase->NumBytesMemBuf);
}
if(ichoose==1 || ichoose==2){
iv=MAX(nv*neta,nvstack);
fname=VNDtempname(file);
vndb = V2Dop(2,750000,sizeof(complex),
fname,(long)ntfft,iv);
fprintf(fpl,"sutifowler: (w,v) RAM mem buf = %ld bytes\n",
vndb->NumBytesMemBuf);
VNDfree(fname,"main: freeing fname 3");
}
/******************************************************************************/
for(k=0;k<nxfftny;k++){ /* loop over spatial wavenumbers */
/******************************************************************************/
if(k==(20*(k/20))) {
fprintf(fpl,"sutifowler: k index = %d out of %d\n",
k,nxfftny);
}
ak=k*dk;
key[0]=k;
key[1]=0;
/******************************************************************************/
if(ichoose==1 || ichoose==2) { /* do Fowler DMO */
/******************************************************************************/
for(iv=0;iv<nvstack;iv++) { /* loop over input velocities */
VNDrw('r',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
31,"Fowler DMO t -> w fft read");
for(it=ntout;it<ntfft;it++) crt[it]=czero;
pfacc(-1,ntfft,crt);
V2Dw0(vndb,iv,ccrt,32);
}
for(iw=0;iw<ntfft;iw++) {
p=0.5*ak/fabs(w[iw]);
if(TI) { /* anisotropic TI*/
ip=p/dp;
if(ip<NP) {
V2Dr0(vndvnmo,ip,(char *)rindex,40);
}else{
for(iv=0;iv<(nv*neta);iv++) rindex[iv]=-1.;
}
}else{ /* isotropic */
p2=p*p;
for(iv=0;iv<nv;iv++){
v2=v[iv]*v[iv];
rindex[iv]=(1-v2*p2)/(v2*dp2);
}
}
V2Dr1(vndb,iw,ccrt,41);
for(iv=0;iv<nvstack;iv++) ctemp[iv]=crt[iv];
ints8c(nvstack,1.0,0.0,ctemp,czero,czero,nv*neta,rindex,crt);
V2Dw1(vndb,iw,ccrt,42);
}
for(iv=0;iv<(nv*neta);iv++) { /* loop over output vel */
V2Dr0(vndb,iv,ccrt,51);
pfacc(1,ntfft,crt);
VNDrw('w',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
52,"Fowler DMO w -> t fft write");
}
}
/******************************************************************************/
if( ichoose==3 && neta>1 ) { /* fix up disk order if only doing TI migrations */
/******************************************************************************/
for(iv=0;iv<nv;iv++) {
VNDrw('r',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
57,"option 3 fixup for multiple eta read");
for(ieta=1;ieta<neta;ieta++) {
VNDrw('w',0,vnd,1,key,0,ccrt,
iv*ntout+ieta*nv*ntout,1,ntout,
58,"option 3 fixup for multiple eta write");
}
}
}
/******************************************************************************/
if( (ichoose==1 || ichoose==3 ) ) { /* do Stolt migration */
/******************************************************************************/
for(iv=0;iv<(nv*neta);iv++) {
if(TI) { /* anisotropic TI */
V2Dr0(vndvphase,iv,ccrt,50);
dpm=rt[0];
dw=2.*PI/(ntfft*dtout);
iwmin=0.5*ak/( (NP-3)*dpm*dw);
for(iw=iwmin+1;iw<ntfftny;iw++) {
p=0.5*ak/fabs(w[iw]);
rp=1.0+p/dpm;
ip=rp;
wgt=rp-ip;
factor=wgt*rt[ip+1]+(1.-wgt)*rt[ip];
rindex[iw]=w[iw]*factor;
rindex[ntfft-iw]=w[ntfft-iw]*factor;
}
fw=-2.*PI/dtout;
rindex[0]=fw;
for(iw=1;iw<iwmin+1;iw++) {
rindex[iw]=fw;
rindex[ntfft-iw]=fw;
}
}else{ /* isotropic */
scale=0.5*v[iv]*ak;
for(iw=0;iw<ntfft;iw++) {
if(fabs(w[iw])>scale) {
factor=scale/w[iw];
factor=sqrt(1+factor*factor);
rindex[iw]=w[iw]*factor;
}else{
rindex[iw]=-2.*PI/dtout;
}
}
}
VNDrw('r',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
61,"Stolt t -> w fft read");
for(it=1;it<ntout;it+=2){
crt[it].r=-crt[it].r;
crt[it].i=-crt[it].i;
}
for(it=ntout;it<ntffts;it++) crt[it]=czero;
pfacc(1,ntffts,crt);
dw=2.*PI/(ntffts*dtout);
fw=-PI/dtout;
ints8c(ntffts,dw,fw,crt,czero,czero,
ntfft,rindex,ctemp);
/* obliquity factor code */
for(iw=0;iw<ntfft;iw++){
factor=fabs(w[iw]/rindex[iw]);
crt[iw].r=factor*ctemp[iw].r;
crt[iw].i=factor*ctemp[iw].i;
}
pfacc(-1,ntfft,crt);
VNDrw('w',0,vnd,1,key,0,ccrt,iv*ntout,1,ntout,
62,"Stolt w->t fft write");
}
}
}
fprintf(fpl,"sutifowler: completed loop over wavenumbers\n");
if(ichoose==1 || ichoose==2) VNDcl(vndb,1);
if(TI && (ichoose==1 || ichoose==2)) VNDcl(vndvnmo,1);
if(TI && (ichoose==1 || ichoose==3)) VNDcl(vndvphase,1);
}
if(ichoose<5) {
/******************************************************************************/
fprintf(fpl,"sutifowler: doing inverse spatial fft's k->x\n");
/******************************************************************************/
for(it=0;it<(ntout*nv*neta);it++) {
V2Dr0(vnd,it,ccrt,71);
pfacr(-1,nxfft,crt,rt);
V2Dw0(vnd,it,ccrt,72);
}
VNDc2r(vnd);
}
/*****************************************************************/
fprintf(fpl,"sutifowler: outputting results\n");
/******************************************************************/
it=0;
for(icmp=0;icmp<ncmps;icmp++) {
key[0]=icmp;
key[1]=0;
for(ieta=0;ieta<neta;ieta++) {
for(iv=0;iv<nv;iv++) {
VNDrw('r',0,vnd,1,key,0,(char *)tr.data,
iv*ntout+ieta*nv*ntout,1,ntout,82,
"outputting all velocities for each cmp");
tr.ns=ntout;
tr.dt=1000000*dtout;
tr.cdp=icmp;
tr.tracf=iv;
tr.offset=v[iv];
tr.cdpt=iv;
tr.sx=icmp*dx;
tr.gx=icmp*dx;
it++;
tr.tracl=it;
tr.tracr=it;
tr.fldr=icmp/ngroup;
tr.ep=10+tr.fldr*ngroup;
tr.igc=ieta;
tr.igi=100*(etamin+ieta*deta);
tr.d1=dtout;
tr.f1=0.;
tr.d2=1.;
tr.f2=0.;
puttr(&tr);
}
}
}
/* close files and return */
VNDcl(vnd,1);
VNDfree(crt,"main: freeing crt");
VNDfree(ctemp,"main: freeing ctemp");
VNDfree(v,"main: freeing v");
VNDfree(p2stack,"main: freeing p2stack");
VNDfree(mute,"main: freeing mute");
VNDfree(off,"main: freeing off");
VNDfree(rindex,"main: freeing rindex");
VNDfree(w,"main: freeing w");
if(VNDtotalmem()!=0) {
fprintf(stderr,"total VND memory at end = %ld\n",
VNDtotalmem());
}
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
float a, b; /* powers for amp and phase */
register float *rt=NULL;/* real trace */
register complex *ct=NULL; /* complex transformed trace */
complex filt; /* pow'd input at one frequency */
int nt; /* number of points on input trace */
size_t ntsize; /* nt in bytes */
float dt; /* sample spacing (secs) on input trace */
int nfft; /* number of points in nfft */
int nf; /* number of frequencies (incl Nyq) */
float onfft; /* 1 / nfft */
int verbose; /* flag to get advisory messages */
size_t nzeros; /* number of padded zeroes in bytes */
cwp_Bool seismic; /* is this seismic data? */
int ntout, sym; /* output params */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Set parameters */
if (!getparint("verbose", &verbose)) verbose = 0;
if (!getparfloat("a", &a)) a = 0.0;
if (!getparfloat("b", &b)) b = 0.0;
if (!getparint("sym",&sym)) sym = 0;
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
seismic = ISSEISMIC(tr.trid);
if (seismic) {
if (verbose) warn("input is seismic data, trid=%d",tr.trid);
dt = ((double) tr.dt)/1000000.0;
}
else {
if (verbose) warn("input is not seismic data, trid=%d",tr.trid);
dt = tr.d1;
}
if (!dt) err("dt or d1 field is zero and not getparred");
nt = tr.ns;
ntsize = nt * FSIZE;
if (!getparint("ntout",&ntout)) ntout=tr.ns;
/* Set up for fft
extra 2 in nfft is to avoid wrap around */
nfft = npfaro(nt, LOOKFAC * nt);
if (nfft >= SU_NFLTS || nfft >= PFA_MAX)
err("Padded nt=%d -- too big", nfft);
nf = nfft/2 + 1;
onfft = 1.0 / nfft;
nzeros = (nfft - nt) * FSIZE;
/* Allocate fft arrays */
rt = ealloc1float(nfft);
ct = ealloc1complex(nf);
/* Loop over traces */
do {
/* Load trace into rt (zero-padded) */
memcpy( (void *) rt, (const void *) tr.data, ntsize);
memset((void *) (rt + nt), 0, nzeros);
/* FFT */
pfarc(1, nfft, rt, ct);
/* Apply filter */
{ register int i;
for (i = 0; i < nf; ++i) {
filt = dopow(ct[i], a, b);
ct[i] = cmul(ct[i], filt);
/* symmetric output: flip sign of odd values */
if (sym){
if (ISODD(i)) {
ct[i].r = -ct[i].r;
ct[i].i = -ct[i].i;
}
}
}
}
/* Invert */
pfacr(-1, nfft, ct, rt);
/* Load traces back in */
{ register int i;
for (i = 0; i < nt; ++i) tr.data[i] = rt[i];
}
puttr(&tr);
} while (gettr(&tr));
return(CWP_Exit());
}
int
main (int argc, char **argv)
{
int nt; /* number of time samples */
int nz; /* number of migrated depth samples */
int nx; /* number of horizontal samples */
int nxshot; /* number of shots to be migrated */
int iz,iw,ix,it,ik; /* loop counters */
int igx; /* integerized gx value */
int ntfft,nxfft; /* fft size */
int nw,truenw,nk; /* number of wave numbers */
int dip=65; /* dip angle */
int oldigx=0; /* old value of integerized gx value */
int oldisx=0; /* old value of integerized sx value */
float sx,gx; /* x source and geophone location */
float gxmin=0.0,gxmax=0.0; /* x source and geophone location */
float min_sx_gx; /* min(sx,gx) */
float oldgx; /* old gx position */
float oldgxmin; /* old gx position */
float oldgxmax; /* old gx position */
float oldsx=0.0; /* old sx position */
int isx=0,nxo; /* index for source and geophone */
int ix1,ix2,ix3,ixshot,il=0,ir=0; /* dummy index */
int lpad,rpad; /* padding on both sides of the migrated section */
float *wl=NULL,*wtmp=NULL;
float fmax;
float f1,f2,f3,f4;
int nf1,nf2,nf3,nf4;
int ntw;
float dt=0.004,dz; /* time and depth sampling interval */
float dw,dk; /* wavenumber and frequency sampling interval */
float fw,fk; /* first wavenumber and frequency */
float w,k; /* wavenumber and frequency */
float dx; /* spatial sampling interval */
float **p=NULL;
float **cresult=NULL; /* input, output data */
float v1,vmin;
double kz1,kz2;
double phase1;
float **v=NULL;
float **vp=NULL;
complex cshift1,cshift2;
complex *wlsp=NULL;
complex **cp=NULL;
complex **cp1=NULL;
complex **cq=NULL;
complex **cq1=NULL; /*complex input,output*/
char *vfile=""; /* name of file containing velocities */
FILE *vfp=NULL;
int verbose; /* verbose flag */
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(1);
/* get optional parameters */
MUSTGETPARINT("nz",&nz);
MUSTGETPARFLOAT("dz",&dz);
MUSTGETPARSTRING("vfile", &vfile);
MUSTGETPARINT("nxo",&nxo);
MUSTGETPARINT("nxshot",&nxshot);
if (!getparfloat("fmax",&fmax)) fmax = 25. ;
if (!getparfloat("f1",&f1)) f1 = 10.0;
if (!getparfloat("f2",&f2)) f2 = 20.0;
if (!getparfloat("f3",&f3)) f3 = 40.0;
if (!getparfloat("f4",&f4)) f4 = 50.0;
if (!getparint("lpad",&lpad)) lpad=9999;
if (!getparint("rpad",&rpad)) rpad=9999;
if (!getparint("dip",&dip)) dip=65;
if (!getparint("verbose",&verbose)) verbose = 0;
/* allocate space */
cresult = alloc2float(nz,nxo);
vp=alloc2float(nxo,nz);
/* load velocity file */
vfp=efopen(vfile,"r");
efread(vp[0],FSIZE,nz*nxo,vfp);
efclose(vfp);
/* zero out cresult array */
memset((void *) cresult[0], 0, nxo*nz*FSIZE);
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
get_sx_gx(&sx,&gx);
min_sx_gx = MIN(sx,gx);
gxmin=gxmax=gx;
erewind(stdin);
/*
sx = sx - min_sx_gx;
gx = gx - min_sx_gx;
*/
/* let user give dt and/or dx from command line */
if (!getparfloat("dt", &dt)) {
if (tr.dt) { /* is dt field set? */
dt = ((double) tr.dt)/1000000.0;
} else { /* dt not set, assume 4 ms */
dt = 0.004;
warn("tr.dt not set, assuming dt=0.004");
}
}
if (!getparfloat("dx",&dx)) {
if (tr.d2) { /* is d2 field set? */
dx = tr.d2;
} else {
dx = 1.0;
warn("tr.d2 not set, assuming d2=1.0");
}
}
do { /* begin loop over shots */
/* determine frequency sampling interval*/
ntfft = npfar(nt);
nw = ntfft/2+1;
dw = 2.0*PI/(ntfft*dt);
/* compute the index of the frequency to be migrated */
fw=2.0*PI*f1;
nf1=fw/dw+0.5;
fw=2.0*PI*f2;
nf2=fw/dw+0.5;
fw=2.0*PI*f3;
nf3=fw/dw+0.5;
fw=2.0*PI*f4;
nf4=fw/dw+0.5;
/* the number of frequencies to migrated */
truenw=nf4-nf1+1;
fw=0.0+nf1*dw;
if (verbose)
warn("nf1=%d nf2=%d nf3=%d nf4=%d nw=%d",nf1,nf2,nf3,nf4,truenw);
/* allocate space */
wl=alloc1float(ntfft);
wlsp=alloc1complex(nw);
/* generate the Ricker wavelet */
wtmp=ricker(fmax,dt,&ntw);
/* zero out wl[] array */
memset((void *) wl, 0, ntfft*FSIZE);
/* CHANGE BY CHRIS STOLK, Dec. 11, 2005 */
/* The next two lines are the old code, */
/* it is erroneous because the peak of */
/* the wavelet occurs at positive time */
/* instead of time zero. */
for(it=0;it<ntw;it++)
wl[it]=wtmp[it];
/* New code: we put in the wavelet in a centered fashion */
/*
for(it=0;it<ntw;it++) {
wl[(it-ntw/2+ntfft) % ntfft]=wtmp[it];
}
*/
/* warn("%12i %12f \n",(it-ntw/2+ntfft) % ntfft,wtmp[it]); */
/* End of new code */
free1float(wtmp);
/* fourier transform wl array */
pfarc(-1,ntfft,wl,wlsp);
/* CS TEST: this was used to output the array wlsp
(the wavelet in the frequency domain) to the file CSinfo,
no longer needed and commented out */
/*
FILE *CSinfo;
CSinfo=fopen("CSinfo","w");
fprintf(CSinfo,"ntfft=%10i\n",ntfft);
fprintf(CSinfo,"ntw=%10i\n",ntw);
for(iw=0;iw<ntfft/2+1;iw++)
fprintf(CSinfo,"%12f %12f \n",wlsp[iw].r,wlsp[iw].i);
fclose(CSinfo);
*/
/* conclusion from the analysis of this info:
the wavelet (whose fourier transform is in wlsp)
is not zero phase!!!
so there is a timeshift error!!!
Conclusion obtained dec 11 2005 */
/* CS */
/* allocate space */
p = alloc2float(ntfft,nxo);
cq = alloc2complex(nw,nxo);
/* zero out p[][] array */
memset((void *) p[0], 0, ntfft*nxo*FSIZE);
/* initialize a number of items before looping over traces */
nx = 0;
if (gx < 0 ) {
igx=gx/dx + nxo;
} else {
igx=gx/dx ;
}
oldigx=igx;
oldsx=sx;
oldgx=gx;
oldgxmax=gxmax;
oldgxmin=gxmin;
while(gettr(&tr)) { /* begin looping over traces within a shot gather */
/* get sx and gx */
get_sx_gx(&sx,&gx);
/*
warn("%d nx=%d", igx, nx);
sx = (sx - min_sx_gx);
gx = (gx - min_sx_gx);
*/
if (gx < 0 ) {
igx=gx/dx + nxo;
} else {
igx=gx/dx ;
}
if (igx==oldigx)
warn("repeated igx!!! check dx or scalco value!!!");
oldigx = igx;
if(tr.sx!=oldsx){ efseeko(stdin,(off_t)(-240-nt*4),SEEK_CUR); break;}
if(gxmin>gx)gxmin=gx;
if(gxmax<gx)gxmax=gx;
if(verbose)
warn(" inside loop: min_sx_gx %f isx %d igx %d gx %f sx %f",min_sx_gx,isx,igx,gx,sx);
/* sx, gx must increase monotonically */
if (!(oldsx <= sx) )
err("sx field must be monotonically increasing!");
if (!(oldgx <= gx) )
err("gx field must be monotonically increasing!");
memcpy( (void *) p[igx], (const void *) tr.data,nt*FSIZE);
++nx;
}
isx=oldsx/dx;
if (isx==oldisx)
warn("repeated isx!!! check dx or scalco value!!!");
oldisx=isx;
ixshot=isx;
if(verbose) {
warn("sx %f, gx %f , gxmin %f gxmax %f nx %d",sx,gx,gxmin,gxmax, nx);
warn("isx %d igx %d ixshot %d" ,isx,igx,ixshot);
}
/* transform the shot gather from time to frequency domain */
pfa2rc(1,1,ntfft,nxo,p[0],cq[0]);
/* compute the most left and right index for the migrated */
/* section */
ix1=oldsx/dx;
ix2=gxmin/dx;
ix3=gxmax/dx;
if(ix1>=ix3)ix3=ix1;
if(ix1<=ix2)ix2=ix1;
il=ix2;
ir=ix3;
ix2-=lpad;
ix3+=rpad;
if(ix2<0)ix2=0;
if(ix3>nxo-1)ix3=nxo-1;
/* the total traces to be migrated */
nx=ix3-ix2+1;
nw=truenw;
/* determine wavenumber sampling (for complex to complex FFT) */
nxfft = npfa(nx);
nk = nxfft;
dk = 2.0*PI/(nxfft*dx);
fk = -PI/dx;
/* allocate space for velocity profile within the aperature */
v=alloc2float(nx,nz);
for(iz=0;iz<nz;iz++)
for(ix=0;ix<nx;ix++)
v[iz][ix]=vp[iz][ix+ix2];
/* allocate space */
cp = alloc2complex(nx,nw);
cp1 = alloc2complex(nx,nw);
/* transpose the frequency domain data from */
/* data[ix][iw] to data[iw][ix] and apply a */
/* Hamming at the same time */
for (ix=0; ix<nx; ix++) {
for (iw=0; iw<nw; iw++){
float tmpp=0.0,tmppp=0.0;
if(iw>=(nf1-nf1)&&iw<=(nf2-nf1)){
tmpp=PI/(nf2-nf1);
tmppp=tmpp*(iw-nf1)-PI;
tmpp=0.54+0.46*cos(tmppp);
cp[iw][ix]=crmul(cq[ix+ix2][iw+nf1],tmpp);
} else {
if(iw>=(nf3-nf1)&&iw<=(nf4-nf1)){
tmpp=PI/(nf4-nf3);
tmppp=tmpp*(iw-nf3);
tmpp=0.54+0.46*cos(tmppp);
cp[iw][ix]=crmul(cq[ix+ix2][iw+nf1],tmpp);
} else {
cp[iw][ix]=cq[ix+ix2][iw+nf1];}
}
cp1[iw][ix]=cmplx(0.0,0.0);
}
}
for(iw=0;iw<nw;iw++){
cp1[iw][ixshot-ix2]=wlsp[iw+nf1];
}
if(verbose) {
warn("ixshot %d ix %d ix1 %d ix2 %d ix3 %d",ixshot,ix,ix1,ix2,ix3);
warn("oldsx %f ",oldsx);
}
free2float(p);
free2complex(cq);
free1float(wl);
free1complex(wlsp);
/* allocating space */
cq=alloc2complex(nxfft,nw);
cq1=alloc2complex(nxfft,nw);
/* loops over depth */
for(iz=0;iz<nz;++iz){
/* the imaging condition */
for(ix=0;ix<nx;ix++){
for(iw=0,w=fw;iw<nw;w+=dw,iw++){
complex tmp;
float ratio=10.0;
if(fabs(ix+ix2-ixshot)*dx<ratio*iz*dz)
tmp=cmul(cp[iw][ix],cp1[iw][ix]);
else
tmp=cmplx(0.0,0.0);
cresult[ix+ix2][iz]+=tmp.r/ntfft;
}
}
/* get the minimum velocity */
vmin=0;
for(ix=il-ix2;ix<=ir-ix2;ix++){
vmin+=1.0/v[iz][ix]/(ir-il+1);
}
vmin=1.0/vmin;
/* compute the shifted wavefield */
for (ik=0;ik<nx;++ik) {
for (iw=0; iw<nw; ++iw) {
cq[iw][ik] = ik%2 ? cneg(cp[iw][ik]) : cp[iw][ik];
cq1[iw][ik] = ik%2 ? cneg(cp1[iw][ik]) : cp1[iw][ik];
}
}
/* zero out cq[][] cq1[][] */
for (ik=nx; ik<nk; ++ik) {
for (iw=0; iw<nw; ++iw) {
cq[iw][ik] = cmplx(0.0,0.0);
cq1[iw][ik] = cmplx(0.0,0.0);
}
}
/* FFT to W-K domain */
pfa2cc(-1,1,nk,nw,cq[0]);
pfa2cc(-1,1,nk,nw,cq1[0]);
v1=vmin;
for(ik=0,k=fk;ik<nk;++ik,k+=dk) {
for(iw=0,w=fw;iw<nw;++iw,w+=dw){
if(w==0.0)w=1.0e-10/dt;
kz1=1.0-pow(v1*k/w,2.0);
if(kz1>0.15){
phase1 = -w*sqrt(kz1)*dz/v1;
cshift1 = cmplx(cos(phase1), sin(phase1));
cq[iw][ik] = cmul(cq[iw][ik],cshift1);
cq1[iw][ik] = cmul(cq1[iw][ik],cshift1);
} else {
cq[iw][ik] = cq1[iw][ik] = cmplx(0.0,0.0);
}
}
}
pfa2cc(1,1,nk,nw,cq[0]);
pfa2cc(1,1,nk,nw,cq1[0]);
for(ix=0;ix<nx;++ix) {
for(iw=0,w=fw;iw<nw;w+=dw,++iw){
float a=0.015,g=1.0;
int I=10;
if(ix<=I)g=exp(-a*(I-ix)*(I-ix));
if(ix>=nx-I)g=exp(-a*(-nx+I+ix)*(-nx+I+ix));
cq[iw][ix] = crmul( cq[iw][ix],1.0/nxfft);
cq[iw][ix] =ix%2 ? cneg(cq[iw][ix]) : cq[iw][ix];
kz2=(1.0/v1-1.0/v[iz][ix])*w*dz;
cshift2=cmplx(cos(kz2),sin(kz2));
cp[iw][ix]=cmul(cq[iw][ix],cshift2);
cq1[iw][ix] = crmul( cq1[iw][ix],1.0/nxfft);
cq1[iw][ix] =ix%2 ? cneg(cq1[iw][ix]) : cq1[iw][ix];
cp1[iw][ix]=cmul(cq1[iw][ix],cshift2);
}
}
}
free2complex(cp);
free2complex(cp1);
free2complex(cq);
free2complex(cq1);
free2float(v);
--nxshot;
} while(nxshot);
/* restore header fields and write output */
for(ix=0; ix<nxo; ix++){
tr.ns = nz;
tr.d1 = dz;
tr.d2 = dx;
tr.offset = 0;
tr.cdp = tr.tracl = ix;
memcpy( (void *) tr.data, (const void *) cresult[ix],nz*FSIZE);
puttr(&tr);
}
return(CWP_Exit());
}
int
main (int argc, char **argv)
{
int nt; /* number of time samples */
int nz; /* number of migrated depth samples */
int nx; /* number of horizontal samples */
int nxshot; /* number of shots to be migrated */
/*int nxshot_orig;*/ /* first value of nxshot */
int iz,iw,ix,it; /* loop counters */
int igx; /* integerized gx value */
int ntfft; /* fft size */
int nw,truenw; /* number of wave numbers */
int dip=79; /* dip angle */
float sx,gx; /* x source and geophone location */
float gxmin=0.0,gxmax=0.0; /* x source and geophone location */
float min_sx_gx; /* min(sx,gx) */
float oldgx; /* old gx position */
/* float oldgxmin; */ /* old gx position */
/* float oldgxmax; */ /* old gx position */
float oldsx=0.0; /* old sx position */
int isx=0,nxo; /* index for source and geophone */
int oldisx=0; /* old value of source index */
int oldigx=0; /* old value of integerized gx value */
int ix1,ix2,ix3,ixshot; /* dummy index */
int lpad,rpad; /* padding on both sides of the migrated section */
float *wl=NULL,*wtmp=NULL;
float fmax;
float f1,f2,f3,f4;
int nf1,nf2,nf3,nf4;
int ntw;
float dt=0.004,dz; /* time and depth sampling interval */
float dw; /* frequency sampling interval */
float fw; /* first frequency */
float w; /* frequency */
float dx; /* spatial sampling interval */
float **p=NULL; /* input data */
float **cresult=NULL; /* output result */
float v1; /* average velocity */
double kz2;
float **v=NULL,**vp=NULL;/* pointers for the velocity profile */
complex cshift2;
complex *wlsp=NULL; /* complex input,output */
complex **cp=NULL; /* ... */
complex **cp1=NULL; /* ... */
complex **cq=NULL; /* ... */
char *vfile=""; /* name of file containing velocities */
FILE *vfp=NULL;
int verbose; /* verbose flag */
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(1);
/* get required parameters */
MUSTGETPARINT("nz",&nz);
MUSTGETPARINT("nxo",&nxo);
MUSTGETPARFLOAT("dz",&dz);
MUSTGETPARSTRING("vfile",&vfile);
MUSTGETPARINT("nxshot",&nxshot);
/* get optional parameters */
if (!getparfloat("fmax",&fmax)) fmax = 25.0;
if (!getparfloat("f1",&f1)) f1 = 10.0;
if (!getparfloat("f2",&f2)) f2 = 20.0;
if (!getparfloat("f3",&f3)) f3 = 40.0;
if (!getparfloat("f4",&f4)) f4 = 50.0;
if (!getparint("lpad",&lpad)) lpad=9999;
if (!getparint("rpad",&rpad)) rpad=9999;
if (!getparint("dip",&dip)) dip=79;
if (!getparint("verbose",&verbose)) verbose = 0;
/* allocating space */
cresult = alloc2float(nz,nxo);
vp = alloc2float(nxo,nz);
/* load velicoty file */
vfp=efopen(vfile,"r");
efread(vp[0],FSIZE,nz*nxo,vfp);
efclose(vfp);
/* zero out cresult array */
memset((void *) cresult[0], 0, nxo*nz*FSIZE);
/* save value of nxshot */
/* nxshot_orig=nxshot; */
/* get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
get_sx_gx(&sx,&gx);
min_sx_gx = MIN(sx,gx);
sx = sx - min_sx_gx;
gx = gx - min_sx_gx;
/* let user give dt and/or dx from command line */
if (!getparfloat("dt", &dt)) {
if (tr.dt) { /* is dt field set? */
dt = ((double) tr.dt)/1000000.0;
} else { /* dt not set, assume 4 ms */
dt = 0.004;
if(verbose) warn("tr.dt not set, assuming dt=0.004");
}
}
if (!getparfloat("dx",&dx)) {
if (tr.d2) { /* is d2 field set? */
dx = tr.d2;
} else {
dx = 1.0;
if(verbose) warn("tr.d2 not set, assuming d2=1.0");
}
}
checkpars();
oldisx=0;
do { /* begin loop over shots */
/* determine frequency sampling interval*/
ntfft = npfar(nt);
nw = ntfft/2+1;
dw = 2.0*PI/(ntfft*dt);
/* compute the index of the frequency to be migrated*/
fw=2.0*PI*f1;
nf1=fw/dw+0.5;
fw=2.0*PI*f2;
nf2=fw/dw+0.5;
fw=2.0*PI*f3;
nf3=fw/dw+0.5;
fw=2.0*PI*f4;
nf4=fw/dw+0.5;
/* the number of frequencies to migrated*/
truenw=nf4-nf1+1;
fw=0.0+nf1*dw;
if(verbose)
warn("nf1=%d nf2=%d nf3=%d nf4=%d nw=%d",nf1,nf2,nf3,nf4,truenw);
/* allocate space */
wl=alloc1float(ntfft);
wlsp=alloc1complex(nw);
/* generate the Ricker wavelet */
wtmp=ricker(fmax,dt,&ntw);
/* zero out wl[] array */
memset((void *) wl, 0, ntfft*FSIZE);
/* CHANGE BY CHRIS STOLK, Dec. 11, 2005 */
/* The next two lines are the old code, */
/* it is erroneous because the peak of */
/* the wavelet occurs at positive time */
/* instead of time zero. */
/*
for(it=0;it<ntw;it++)
wl[it]=wtmp[it];
*/
/* New code: we put in the wavelet in a centered fashion */
for(it=0;it<ntw;it++)
wl[(it-ntw/2+ntfft) % ntfft]=wtmp[it];
/* End of new code */
free1float(wtmp);
/* fourier transform wl array */
pfarc(-1,ntfft,wl,wlsp);
/* allocate space */
p = alloc2float(ntfft,nxo);
cq = alloc2complex(nw,nxo);
/* zero out p[][] array */
memset((void *) p[0], 0, ntfft*nxo*FSIZE);
/* initialize a number of items before looping over traces */
nx = 0;
igx=0;
oldigx=0;
oldsx=sx;
oldgx=gx;
/* oldgxmax=gxmax; */
/* oldgxmin=gxmin; */
do { /* begin looping over traces within a shot gather */
memcpy( (void *) p[igx], (const void *) tr.data,nt*FSIZE);
/* get sx and gx */
get_sx_gx(&sx,&gx);
sx = (sx - min_sx_gx);
gx = (gx - min_sx_gx);
igx = NINT(gx/dx);
if (igx==oldigx)
warn("repeated igx!!! check dx or scalco value!!!");
oldigx = igx;
if(gxmin>gx)gxmin=gx;
if(gxmax<gx)gxmax=gx;
if(verbose)
warn(" inside loop: min_sx_gx %f isx %d igx %d gx %f sx %f",min_sx_gx,isx,igx,gx,sx);
/* sx, gx must increase monotonically */
if (!(oldsx <= sx) )
err("sx field must be monotonically increasing!");
if (!(oldgx <= gx) )
err("gx field must be monotonically increasing!");
++nx;
} while(gettr(&tr) && sx==oldsx);
isx=NINT(oldsx/dx);
ixshot=isx;
if (isx==oldisx)
warn("repeated isx!!! check dx or scalco value!!!");
oldisx=isx;
if(verbose) {
warn("sx %f, gx %f , gxmin %f gxmax %f nx %d",sx,gx,gxmin,gxmax, nx);
warn("isx %d igx %d ixshot %d" ,isx,igx,ixshot);
}
/* transform the shot gather from time to frequency domain */
pfa2rc(1,1,ntfft,nxo,p[0],cq[0]);
/* compute the most left and right index for the migrated */
/* section */
ix1=NINT(oldsx/dx);
ix2=NINT(gxmin/dx);
ix3=NINT(gxmax/dx);
if(ix1>=ix3)ix3=ix1;
if(ix1<=ix2)ix2=ix1;
ix2-=lpad;
ix3+=rpad;
if(ix2<0)ix2=0;
if(ix3>nxo-1)ix3=nxo-1;
/* the total traces to be migrated */
nx=ix3-ix2+1;
nw=truenw;
/* allocate space for velocity profile within the aperature */
v=alloc2float(nx,nz);
for(iz=0;iz<nz;iz++)
for(ix=0;ix<nx;ix++)
v[iz][ix]=vp[iz][ix+ix2];
/* allocate space */
cp = alloc2complex(nx,nw);
cp1 = alloc2complex(nx,nw);
/* transpose the frequency domain data from */
/* data[ix][iw] to data[iw][ix] and apply a */
/* Hamming at the same time */
for (ix=0; ix<nx; ++ix) {
for (iw=0; iw<nw; iw++){
float tmpp=0.0,tmppp=0.0;
if(iw>=(nf1-nf1)&&iw<=(nf2-nf1)){
tmpp=PI/(nf2-nf1);
tmppp=tmpp*(iw-nf1)-PI;
tmpp=0.54+0.46*cos(tmppp);
cp[iw][ix]=crmul(cq[ix+ix2][iw+nf1],tmpp);
} else {
if(iw>=(nf3-nf1)&&iw<=(nf4-nf1)) {
tmpp=PI/(nf4-nf3);
tmppp=tmpp*(iw-nf3);
tmpp=0.54+0.46*cos(tmppp);
cp[iw][ix]=crmul(cq[ix+ix2][iw+nf1],tmpp);
} else {
cp[iw][ix]=cq[ix+ix2][iw+nf1];
}
}
cp1[iw][ix]=cmplx(0.0,0.0);
}
}
for(iw=0;iw<nw;iw++){
cp1[iw][ixshot-ix2]=wlsp[iw+nf1];
}
if(verbose) {
warn("ixshot %d ix %d ix1 %d ix2 %d ix3 %d",ixshot,ix,ix1,ix2,ix3);
warn("oldsx %f ",oldsx);
}
free2float(p);
free2complex(cq);
free1float(wl);
free1complex(wlsp);
/* loops over depth */
for(iz=0; iz<nz; ++iz) {
/* the imaging condition */
for(ix=0; ix<nx; ++ix){
for(iw=0,w=fw;iw<nw;w+=dw,iw++){
complex tmp;
float ratio=10.0;
if(fabs(ix+ix2-ixshot)*dx<ratio*iz*dz)
tmp=cmul(cp[iw][ix],cp1[iw][ix]);
else
tmp=cmplx(0.0,0.0);
cresult[ix+ix2][iz]+=tmp.r/ntfft;
}
}
/* get the average velocity */
v1=0.0;
for(ix=0;ix<nx;++ix)
v1+=v[iz][ix]/nx;
/* compute time-invariant wavefield */
for(ix=0;ix<nx;++ix) {
for(iw=0,w=fw;iw<nw;w+=dw,++iw) {
kz2=-(1.0/v1)*w*dz;
cshift2=cmplx(cos(kz2),sin(kz2));
cp[iw][ix]=cmul(cp[iw][ix],cshift2);
cp1[iw][ix]=cmul(cp1[iw][ix],cshift2);
}
}
/* wave-propagation using finite-difference method */
fdmig(cp, nx, nw,v[iz],fw,dw,dz,dx,dt,dip);
fdmig(cp1,nx, nw,v[iz],fw,dw,dz,dx,dt,dip);
/* apply thin lens term here */
for(ix=0;ix<nx;++ix) {
for(iw=0,w=fw;iw<nw;w+=dw,++iw){
kz2=-(1.0/v[iz][ix]-1.0/v1)*w*dz;
cshift2=cmplx(cos(kz2),sin(kz2));
cp[iw][ix]=cmul(cp[iw][ix],cshift2);
cp1[iw][ix]=cmul(cp1[iw][ix],cshift2);
}
}
}
free2complex(cp);
free2complex(cp1);
free2float(v);
--nxshot;
} while(nxshot);
/* restore header fields and write output */
for(ix=0; ix<nxo; ix++){
tr.ns = nz;
tr.d1 = dz;
tr.d2 = dx;
tr.offset = 0;
tr.cdp = tr.tracl = ix;
memcpy( (void *) tr.data, (const void *) cresult[ix],nz*FSIZE);
puttr(&tr);
}
return(CWP_Exit());
}
int
main(int argc, char **argv)
{
register float *rt; /* real trace */
register complex *ct; /* complex transformed trace */
int nt; /* number of points on input trace */
int nfft; /* transform length */
int nf; /* number of frequencies */
int sign; /* sign in exponent of transform */
int verbose; /* flag to get advisory messages */
float dt; /* sampling interval in secs */
float d1; /* output sample interval in Hz */
cwp_Bool seismic; /* is this seismic data? */
float c; /* multiplier */
float w0, w1, w2; /* weights */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
if (!getparint("verbose", &verbose)) verbose=1;
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
/* check for seismic or well log data */
seismic = ISSEISMIC(tr.trid);
if (seismic) {
if (verbose) warn("input is seismic data, trid=%d",tr.trid);
dt = ((double) tr.dt)/1000000.0;
}
else {
if (verbose) warn("input is not seismic data, trid=%d",tr.trid);
dt = tr.d1;
}
if (!dt) {
dt = .004;
if (verbose) warn("dt or d1 not set, assumed to be .004");
}
/* Set up pfa fft */
nfft = npfaro(nt, LOOKFAC * nt);
if (nfft >= SU_NFLTS || nfft >= PFA_MAX) err("Padded nt=%d--too big", nfft);
nf = nfft/2 + 1;
d1 = 1.0/(nfft*dt);
if (!getparint("sign", &sign)) sign = 1;
if (sign != 1 && sign != -1) err("sign = %d must be 1 or -1", sign);
/* get weights */
if (!getparfloat("w0",&w0)) w0 = 0.75;
if (!getparfloat("w1",&w1)) w1 = 1.00;
if (!getparfloat("w2",&w2)) w2 = 0.75;
rt = ealloc1float(nfft);
ct = ealloc1complex(nf);
/* If dt not set, issue advisory on frequency step d1 */
if (dt && verbose) warn("d1=%f", 1.0/(nfft*dt));
/* Main loop over traces */
do {
register int i;
/* Load trace into rt (zero-padded) */
memcpy((void *) rt, (const void *) tr.data, nt*FSIZE);
memset((void *) (rt + nt), (int) '\0', (nfft-nt)*FSIZE);
/* FFT */
pfarc(sign, nfft, rt, ct);
/* Store values */
for (i = 0; i < nf; ++i) {
c =w0*rcabs(ct[i-1])+w1*rcabs(ct[i])+w2*rcabs(ct[i+1]);
if (i==0 || i==nf) {
tr.data[2*i] = ct[i].r / rcabs(ct[i]);
tr.data[2*i+1] = ct[i].i / rcabs(ct[i]);
} else {
tr.data[2*i] = ct[i].r / c;
tr.data[2*i+1] = ct[i].i / c;
}
}
/* Set header values--npfaro makes nfft even */
tr.ns = 2 * nf;
tr.trid = FUNPACKNYQ;
tr.d1 = d1;
tr.f1 = 0.0;
puttr(&tr);
} while (gettr(&tr));
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;
}
int
main(int argc, char **argv)
{
register float *rt; /* real trace */
register complex *ct; /* complex transformed trace */
int nt; /* number of points on input trace */
int nfft; /* number of points on output trace */
int nfby2p1; /* nfft/2 + 1 */
float dt; /* sample interval in secs */
float d1; /* output sample interval in Hz */
int ntr=0; /* number of traces */
register int i; /* counter */
/* Initialize */
initargs(argc, argv);
requestdoc(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;
warn("dt not set, assumed to be .004");
}
checkpars();
/* Set up pfa fft */
nfft = npfaro(nt, LOOKFAC * nt);
if (nfft >= SU_NFLTS || nfft >= PFA_MAX)
err("Padded nt=%d--too big", nfft);
nfby2p1 = nfft/2 + 1;
d1 = 1.0/(nfft*dt);
rt = ealloc1float(nfft);
ct = ealloc1complex(nfby2p1);
/* Main loop over traces */
do {
++ntr;
/* Load trace into rt (zero-padded) */
memcpy( (void *) rt, (const void *) tr.data, nt*FSIZE);
memset( (void *) (rt + nt), 0, (nfft - nt)*FSIZE);
/* FFT */
pfarc(1, nfft, rt, ct);
/* Compute amplitude spectrum */
tr.data[0] = rcabs(ct[0])/2.0;
for (i = 1; i < nfby2p1; ++i) tr.data[i] = rcabs(ct[i]);
/* Set header values */
tr.ns = nfby2p1;
tr.dt = 0; /* d1=df is now the relevant step size */
tr.trid = AMPLITUDE;
tr.d1 = d1;
tr.f1 = 0.0;
puttr(&tr);
} while (gettr(&tr));
return(CWP_Exit());
}
