int defineSource(wavPar wav, srcPar src, float **src_nwav, int reverse, int verbose)
{
FILE *fp;
size_t nread;
int optn, nfreq, i, j, k, iwmax, tracesToDo;
int iw, n1, namp;
float scl, d1, df, deltom, om, tshift;
float amp1, amp2, amp3;
float *trace, maxampl;
complex *ctrace, tmp;
segy hdr;
n1 = wav.nt;
if (wav.random) { /* initialize random sequence */
srand48(wav.seed+1);
seedCMWC4096();
for (i=0; i<8192; i++) {
amp1 = dcmwc4096();
}
}
else {
/* read first header and last byte to get file size */
fp = fopen( wav.file_src, "r" );
assert( fp != NULL);
nread = fread( &hdr, 1, TRCBYTES, fp );
assert(nread == TRCBYTES);
/* read all traces */
tracesToDo = wav.nx;
i = 0;
while (tracesToDo) {
memset(&src_nwav[i][0],0,n1*sizeof(float));
nread = fread(&src_nwav[i][0], sizeof(float), hdr.ns, fp);
assert (nread == hdr.ns);
nread = fread( &hdr, 1, TRCBYTES, fp );
if (nread==0) break;
tracesToDo--;
i++;
}
fclose(fp);
}
optn = optncr(2*n1);
nfreq = optn/2 + 1;
ctrace = (complex *)calloc(nfreq,sizeof(complex));
trace = (float *)calloc(optn,sizeof(float));
df = 1.0/(optn*wav.dt);
deltom = 2.*M_PI*df;
scl = 1.0/optn;
maxampl=0.0;
iwmax = nfreq;
for (i=0; i<wav.nx; i++) {
if (wav.random) {
randomWavelet(wav, src, &src_nwav[i][0], src.tbeg[i], src.tend[i], verbose);
}
else {
memset(&ctrace[0].r,0,nfreq*sizeof(complex));
memset(&trace[0],0,optn*sizeof(float));
memcpy(&trace[0],&src_nwav[i][0],n1*sizeof(float));
rc1fft(trace,ctrace,optn,-1);
/* Scale source from file with -j/w (=1/(jw)) for volume source injections
no scaling is applied for volume source injection rates */
if (src.injectionrate==0) {
for (iw=1;iw<iwmax;iw++) {
om = 1.0/(deltom*iw);
tmp.r = om*ctrace[iw].i;
tmp.i = -om*ctrace[iw].r;
ctrace[iw].r = tmp.r;
ctrace[iw].i = tmp.i;
}
}
/*
*/
if (src.type < 6) { // shift wavelet with +1/2 DeltaT due to staggered in time
tshift=0.5*wav.dt;
for (iw=1;iw<iwmax;iw++) {
om = deltom*iw*tshift;
tmp.r = ctrace[iw].r*cos(-om) - ctrace[iw].i*sin(-om);
tmp.i = ctrace[iw].i*cos(-om) + ctrace[iw].r*sin(-om);
ctrace[iw].r = tmp.r;
ctrace[iw].i = tmp.i;
}
}
/* zero frequency iw=0 set to 0 if the next sample has amplitude==0*/
amp1 = sqrt(ctrace[1].r*ctrace[1].r+ctrace[1].i*ctrace[1].i);
if (amp1 == 0.0) {
ctrace[0].r = ctrace[0].i = 0.0;
}
else { /* stabilization for w=0: extrapolate amplitudes to 0 */
amp2 = sqrt(ctrace[2].r*ctrace[2].r+ctrace[2].i*ctrace[2].i);
amp3 = sqrt(ctrace[3].r*ctrace[3].r+ctrace[3].i*ctrace[3].i);
ctrace[0].r = amp1+(2.0*(amp1-amp2)-(amp2-amp3));
ctrace[0].i = 0.0;
if (ctrace[1].r < 0.0) {
ctrace[0].r *= -1.0;
}
}
for (iw=iwmax;iw<nfreq;iw++) {
ctrace[iw].r = 0.0;
ctrace[iw].i = 0.0;
}
cr1fft(ctrace,trace,optn,1);
/* avoid a (small) spike in the last sample
this is done to avoid diffraction from last wavelet sample
which will act as a pulse */
if (reverse) {
for (j=0; j<n1; j++) src_nwav[i][j] = scl*(trace[n1-j-1]-trace[0]);
// for (j=0; j<n1; j++) src_nwav[i][j] = scl*(trace[j]-trace[optn-1]);
}
else {
for (j=0; j<n1; j++) src_nwav[i][j] = scl*(trace[j]-trace[optn-1]);
}
}
}
free(ctrace);
free(trace);
/* use random amplitude gain factor for each source */
if (src.amplitude > 0.0) {
namp=wav.nx*10;
trace = (float *)calloc(2*namp,sizeof(float));
for (i=0; i<wav.nx; i++) {
if (src.distribution) {
scl = gaussGen()*src.amplitude;
k = (int)MAX(MIN(namp*(scl+5*src.amplitude)/(10*src.amplitude),namp-1),0);
d1 = 10.0*src.amplitude/(namp-1);
}
else {
scl = (float)(drand48()-0.5)*src.amplitude;
k = (int)MAX(MIN(namp*(scl+1*src.amplitude)/(2*src.amplitude),namp-1),0);
d1 = 2.0*src.amplitude/(namp-1);
}
trace[k] += 1.0;
/* trace[i] = scl; */
if (wav.random) n1 = wav.nsamp[i];
else n1 = wav.nt;
for (j=0; j<n1; j++) {
src_nwav[i][j] *= scl;
}
}
if (verbose>2) writesufile("src_ampl.su", trace, namp, 1, -5*src.amplitude, 0.0, d1, 1);
/*
qsort(trace,wav.nx,sizeof(float), comp);
for (i=0; i<wav.nx; i++) {
scl = trace[i];
trace[i] = normal(scl, 0.0, src.amplitude);
}
if (verbose>2) writesufile("src_ampl.su", trace, wav.nx, 1, -5*src.amplitude, 0.0, d1, 1);
*/
free(trace);
}
if (verbose>3) writesufilesrcnwav("src_nwav.su", src_nwav, wav, wav.nt, wav.nx, 0.0, 0.0, wav.dt, 1);
/* set maximum amplitude in source file to 1.0 */
/*
assert(maxampl != 0.0);
scl = wav.dt/(maxampl);
scl = 1.0/(maxampl);
for (i=0; i<wav.nx; i++) {
for (j=0; j<n1; j++) {
src_nwav[i*n1+j] *= scl;
}
}
*/
return 0;
}
void kxwdecomp(complex *rp, complex *rvz, complex *up, complex *down,
int nkx, float dx, int nt, float dt, float fmin, float fmax,
float cp, float rho, int verbose)
{
int iom, iomin, iomax, ikx, nfreq, a, av;
float omin, omax, deltom, om, kp, df, dkx;
float alpha, eps, *angle, avrp, avrvz, maxrp, maxrvz;
float fangle, pangle, vangle, kangle;
complex *pu, w;
complex ax, az;
df = 1.0/((float)nt*dt);
dkx = 2.0*M_PI/(nkx*dx);
deltom = 2.*M_PI*df;
omin = 2.*M_PI*fmin;
omax = 2.*M_PI*fmax;
nfreq = nt/2+1;
eps = 0.01;
alpha = 0.1;
iomin = (int)MIN((omin/deltom), (nfreq-1));
iomin = MAX(iomin, 1);
iomax = MIN((int)(omax/deltom), (nfreq-1));
pu = (complex *)malloc(nkx*sizeof(complex));
angle = (float *)calloc(2*90,sizeof(float));
/* estimate maximum propagation angle in wavefields P and Vz */
for (a=1; a<90; a++) {
for (iom = iomin; iom <= iomax; iom++) {
om = iom*deltom;
ikx = MIN(NINT( ((om/cp)*sin(a*M_PI/180.0))/dkx ), nkx/2);
if (ikx < nkx/2 && ikx != 0) {
ax.r = rp[iom*nkx+ikx].r + rp[iom*nkx+nkx-1-ikx].r;
ax.i = rp[iom*nkx+ikx].i + rp[iom*nkx+nkx-1-ikx].i;
angle[a] += sqrt(ax.r*ax.r + ax.i*ax.i);
ax.r = rvz[iom*nkx+ikx].r + rvz[iom*nkx+nkx-1-ikx].r;
ax.i = rvz[iom*nkx+ikx].i + rvz[iom*nkx+nkx-1-ikx].i;
angle[90+a] += sqrt(ax.r*ax.r + ax.i*ax.i);
}
}
}
avrp =0.0;
avrvz =0.0;
maxrp =0.0;
maxrvz=0.0;
for (a=1; a<90; a++) {
avrp += angle[a];
maxrp = MAX(angle[a], maxrp);
avrvz += angle[90+a];
maxrvz = MAX(angle[90+a], maxrvz);
}
avrp = avrp/89.0;
avrvz = avrvz/89.0;
if (verbose>=4) {
writesufile("anglerp.su", angle, 90, 1, 0, 0, 1, 1);
writesufile("anglervz.su", &angle[90], 90, 1, 0, 0, 1, 1);
}
for (av=0; av<90; av++) {
if (angle[89-av] <= avrp) angle[89-av] = 0.0;
else {
pangle=1.0*(90-av);
break;
}
}
for (av=0; av<90; av++) {
if (angle[179-av] <= avrvz) angle[179-av] = 0.0;
else {
vangle=1.0*(90-av);
break;
}
}
if (verbose>=4) {
writesufile("anglerp0.su", angle, 90, 1, 0, 0, 1, 1);
writesufile("anglervz0.su", &angle[90], 90, 1, 0, 0, 1, 1);
}
fangle=pangle;
if (verbose>=2) vmess("Up-down going: P max=%e average=%e => angle at average %f", maxrp, avrp, pangle);
if (verbose>=2) vmess("Up-down going: Vz max=%e average=%e => angle at average %f", maxrvz, avrvz, vangle);
if (pangle >= 90 || pangle <= 1) { /* use angle in Vz data, P might be placed on free surface */
fangle = vangle;
}
if(!getparfloat("kangle",&kangle)) kangle=fangle;
if (verbose>=2) vmess("Up-down going: maximum angle in decomposition= %f", kangle);
for (iom = iomin; iom <= iomax; iom++) {
om = iom*deltom;
decud(om, rho, cp, dx, nkx, kangle, alpha, eps, pu);
/*
kxwfilter(dpux, kp, dx, nkx, alfa1, alfa2, perc);
kxwfilter(dpuz, kp, dx, nkx, alfa1, alfa2, perc);
*/
for (ikx = 0; ikx < nkx; ikx++) {
ax.r = 0.5*rp[iom*nkx+ikx].r;
ax.i = 0.5*rp[iom*nkx+ikx].i;
az.r = 0.5*(rvz[iom*nkx+ikx].r*pu[ikx].r - rvz[iom*nkx+ikx].i*pu[ikx].i);
az.i = 0.5*(rvz[iom*nkx+ikx].i*pu[ikx].r + rvz[iom*nkx+ikx].r*pu[ikx].i);
down[iom*nkx+ikx].r = ax.r + az.r;
down[iom*nkx+ikx].i = ax.i + az.i;
up[iom*nkx+ikx].r = ax.r - az.r;
up[iom*nkx+ikx].i = ax.i - az.i;
}
}
free(pu);
free(angle);
return;
}
