int main (int argc, char **argv)
{
int nt,it,np,ntau,itau,nx,ix,nk,nkmax,ik,
ntfft,nxfft,nv,trans,norm,conv,verbose;
float dt,dx,dpx,k,dk,kscl,t,*tt,*vt,*tmig,*vmig,
(*vsind)[4],**ptx,**divcor;
complex **ptk;
char *vfile="";
FILE *hfp,*tfp;
/* hook up getpar */
initargs(argc,argv);
requestdoc(1);
/* get information from the first header */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
dt = tr.dt/1000000.0;
/* get parameters */
if (!getparfloat("dxcdp",&dx)) err("dxcdp required");
if (!getparint("np",&np)) np=50;
if (!getparint("trans",&trans)) trans=0;
if (!getparint("norm",&norm)) norm=1;
if (!getparint("conv",&conv)) conv=0;
if (!getparint("verbose",&verbose)) verbose=0;
/* get velocity function */
vt=ealloc1float(nt);
tt=ealloc1float(nt);
for (it=0; it<nt; it++)
tt[it]=it*dt;
if (!getparstring ("vfile",&vfile)){
ntau = countparval("tmig");
if (ntau==0) ntau=1;
tmig = ealloc1float(ntau);
if (!getparfloat("tmig",tmig)) tmig[0] = 0.0;
nv = countparval("vmig");
if (nv==0) nv=1;
if (nv!=ntau)
err("number of tmig and vmig must be equal");
vmig = ealloc1float(nv);
if (!getparfloat("vmig",vmig)) vmig[0] = 1500.0;
for (itau=1; itau<ntau; itau++)
if (tmig[itau]<=tmig[itau-1])
err("tmig must increase monotonically");
for (it=0,t=0.0; it<nt; ++it,t+=dt)
intlin(ntau,tmig,vmig,vmig[0],vmig[ntau-1],
1,&t,&vt[it]);
if (ntau!=nt){
vsind = (float (*)[4])ealloc1float(ntau*4);
cmonot(ntau,tmig,vmig,vsind);
intcub(0,ntau,tmig,vsind,nt,tt,vt);
}
} else{
if (fread(vt,sizeof(float),nt,fopen(vfile,"r"))!=nt)
err("Not %d velocities in file %s",nt,vfile);
}
/* copy traces and headers to temporary files */
tfp = tmpfile();
hfp = tmpfile();
nx = 0;
do {
nx++;
fwrite(&tr,HDRBYTES,1,hfp);
fwrite(tr.data,sizeof(float),nt,tfp);
} while(gettr(&tr));
fseek(hfp,0L,SEEK_SET);
fseek(tfp,0L,SEEK_SET);
if (verbose) fprintf(stderr,"\t%d traces input\n",nx);
/* determine wavenumber and frequency sampling */
nxfft = npfar(nx);
ntfft = npfa(nt);
nk = nxfft/2+1;
dx *= 0.001;
dk = 2.0*PI/(nxfft*dx);
/* allocate space for Fourier transform */
ptk = ealloc2complex(nt,nk);
ptx = ealloc1(nxfft,sizeof(float*));
for (ix=0; ix<nxfft; ++ix)
ptx[ix] = (float*)ptk[0]+ix*nt;
/* allocate space for divergence correction */
divcor=ealloc2float(nt,np);
/* build table of divergence corrections */
divcortable(nt,np,dt,tt,vt,divcor,trans,norm);
/* apply conventional correction if required */
if (conv==1){
for (ix=0; ix<nx; ++ix){
efread(ptx[ix],sizeof(float),nt,tfp);
for (it=0; it<nt; ++it)
ptx[ix][it] *= divcor[0][it];
}
} else {
/* read and apply fft scaling to traces */
kscl = 1.0/nxfft;
for (ix=0; ix<nx; ++ix) {
efread(ptx[ix],sizeof(float),nt,tfp);
for (it=0; it<nt; ++it)
ptx[ix][it] *= kscl;
}
/* pad with zeros */
for (ix=nx; ix<nxfft; ++ix)
for (it=0; it<nt; ++it)
ptx[ix][it] = 0.0;
/* Fourier transform ptx(t,x) to ptk(t,k) */
pfa2rc(-1,2,nt,nxfft,ptx[0],ptk[0]);
if (verbose) fprintf(stderr,"\tFourier transform done\n");
/* define relevant k range */
nkmax = MIN(nk,NINT(PI/dt/vt[0]/dk));
dpx = 1.0/(np-1)/vt[0];
fprintf(stderr,
"nkmax %d nk %d dk %f dpx %f \n",nkmax,nk,dk,dpx);
/* special case k=0 */
for (it=0; it<nt; it++){
ptk[0][it].r *= divcor[0][it];
ptk[0][it].i *= divcor[0][it];
}
/* loop over wavenumbers */
for (ik=1,k=dk; ik<nkmax; ++ik,k+=dk){
/* report */
if (verbose && ik%(nkmax/10>0?nkmax/10:1)==0)
fprintf(stderr,"\t%d of %d wavenumbers done\n",
ik,nkmax);
/* dip filter divergence correction */
dipfilt(k,dpx,dt,np,ntfft,nt,divcor,ptk[ik],ptk[ik]);
}
/* Fourier transform p(t,k) to p(t,x) */
pfa2cr(1,2,nt,nxfft,ptk[0],ptx[0]);
if (verbose)
fprintf(stderr,"\tinverse Fourier transform done\n");
} /* end else dipdivcor */
/* output migrated traces with headers */
for (ix=0; ix<nx; ++ix) {
efread(&tr,HDRBYTES,1,hfp);
memcpy((void *) tr.data,
(const void *) ptx[ix], nt*sizeof(float));
puttr(&tr);
}
return EXIT_SUCCESS;
}
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[] )
{
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;
}
