/* Value getpar -- omitted string type for now */
void getparval(String name, String type, int n, Value *valp)
{
register int k;
short *h;
unsigned short *u;
long *l;
unsigned long *v;
int *i;
unsigned int *p;
float *f;
double *d;
switch(*type) {
case 'h':
h = (short*) ealloc1(n, sizeof(short));
getparshort(name, h);
for (k = 0; k < n; ++k) valp[k].h = h[k];
break;
case 'u':
u = (unsigned short*) ealloc1(n, sizeof(unsigned short));
getparushort(name, u);
for (k = 0; k < n; ++k) valp[k].u = u[k];
break;
case 'l':
l = (long*) ealloc1(n, sizeof(long));
getparlong(name, l);
for (k = 0; k < n; ++k) valp[k].l = l[k];
break;
case 'v':
v = (unsigned long*) ealloc1(n, sizeof(unsigned long));
getparulong(name, v);
for (k = 0; k < n; ++k) valp[k].v = v[k];
break;
case 'i':
i = (int*) ealloc1(n, sizeof(int));
getparint(name, i);
for (k = 0; k < n; ++k) valp[k].i = i[k];
break;
case 'p':
p = (unsigned int*) ealloc1(n, sizeof(unsigned int));
getparuint(name, p);
for (k = 0; k < n; ++k) valp[k].p = p[k];
break;
case 'f':
f = (float*) ealloc1(n, sizeof(float));
getparfloat(name, f);
for (k = 0; k < n; ++k) valp[k].f = f[k];
break;
case 'd':
d = (double*) ealloc1(n, sizeof(double));
getpardouble(name, d);
for (k = 0; k < n; ++k) valp[k].d = d[k];
break;
default:
err("getparval: %d: mysterious type %s", __LINE__, type);
}
}
int main (int argc, char **argv) {
short verbose;
double part, wb, vzero, k, twt, t, depth;
initargs(argc, argv);
if (!getparshort("verbose" , &verbose)) verbose = 0;
if (!getpardouble("wb", &wb)) {
fprintf ( stderr, "Must input water-bottom (wb) parameter --> exiting" );
return EXIT_FAILURE;
}
if (!getpardouble("twt", &twt)) {
fprintf ( stderr, "Must input Two-Way Time (twt) parameter --> exiting" );
return EXIT_FAILURE;
}
if (!getpardouble("vzero", &vzero)) {
fprintf ( stderr, "Must input VZERO (vzero) parameter --> exiting" );
return EXIT_FAILURE;
}
if (!getpardouble("depth", &depth)) {
fprintf ( stderr, "Must input DEPTH (depth) parameter --> exiting" );
return EXIT_FAILURE;
}
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "Water-Bottm = %f\n", wb );
fprintf ( stderr, "TWT = %f\n", twt );
fprintf ( stderr, "VZERO = %f\n", vzero );
fprintf ( stderr, "DEPTH = %f\n", depth );
fprintf ( stderr, "\n" );
}
t = ( twt * 0.0005 ) - ( wb / vzero );
part = vzero * exp ( t );
k = -1.0 * ( vzero / ( depth - part - wb ) );
printf ( "K = %.15f\n", k );
k = 0.48;
fprintf ( stderr, "DEPTH check = %f\n", (vzero/k) * ( exp ( k * t ) - 1 ) + wb );
return EXIT_SUCCESS;
}
int main (int argc, char **argv) {
char *coeff_x, *coeff_x2, *coeff_x3, file[BUFSIZ];
cwp_Bool active = TRUE;
struct GRD_HEADER grd_x, grd_x2, grd_x3;
struct GMT_EDGEINFO edgeinfo_x, edgeinfo_x2, edgeinfo_x3;
struct GMT_BCR bcr_x, bcr_x2, bcr_x3;
short check, verbose;
int nz, ntr, ns;
double value, scale_factor, dz, x_loc, y_loc;
double weight_x, weight_x2, weight_x3;
double value_coeff_x, value_coeff_x2, value_coeff_x3, tr_sec, dt_sec;
float depth_input, amp_output, *tr_amp, *depth;
register int k, n;
initargs(argc, argv);
argc = GMT_begin (argc, argv);
if (!getparstring("coeff_x", &coeff_x)) {
fprintf ( stderr, "Must supply Coefficient_X GMT grid (COEFF_X Parameter) --> exiting\n" );
return EXIT_FAILURE;
}
if (!getparstring("coeff_x2", &coeff_x2)) {
fprintf ( stderr, "Must supply Coefficient_X2 GMT grid (COEFF_X2 Parameter)--> exiting\n" );
return EXIT_FAILURE;
}
if (!getparstring("coeff_x3", &coeff_x3)) {
fprintf ( stderr, "Must supply Coefficient_X3 GMT grid (COEFF_X3 Parameter)--> exiting\n" );
return EXIT_FAILURE;
}
if (!getparshort("verbose" , &verbose)) verbose = 0;
if (!getpardouble("weight_x", &weight_x)) weight_x = 1.0;
if (!getpardouble("weight_x2", &weight_x2)) weight_x2 = 1.0;
if (!getpardouble("weight_x3", &weight_x3)) weight_x3 = 1.0;
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "X1 Coefficient GMT grid file name = %s\n", coeff_x );
fprintf ( stderr, "X2 Coefficient GMT grid file name = %s\n", coeff_x2 );
fprintf ( stderr, "X3 Coefficient GMT grid file name = %s\n", coeff_x3 );
fprintf ( stderr, "X1 Grid Weighting Value = %f\n", weight_x );
fprintf ( stderr, "X2 Grid Weighting Value = %f\n", weight_x2 );
fprintf ( stderr, "X3 Grid Weighting Value = %f\n", weight_x3 );
fprintf ( stderr, "\n" );
}
weight_x = 1.0 / weight_x;
weight_x2 = 1.0 / weight_x2;
weight_x3 = 1.0 / weight_x3;
GMT_boundcond_init (&edgeinfo_x);
GMT_boundcond_init (&edgeinfo_x2);
GMT_boundcond_init (&edgeinfo_x3);
GMT_grd_init (&grd_x, argc, argv, FALSE);
GMT_grd_init (&grd_x2, argc, argv, FALSE);
GMT_grd_init (&grd_x3, argc, argv, FALSE);
if (GMT_read_grd_info (coeff_x, &grd_x)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x2, &grd_x2)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x3, &grd_x3)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
f1 = (float *) GMT_memory (VNULL, (size_t)((grd_x.nx + 4) * (grd_x.ny + 4)), sizeof(float), GMT_program);
f2 = (float *) GMT_memory (VNULL, (size_t)((grd_x2.nx + 4) * (grd_x2.ny + 4)), sizeof(float), GMT_program);
f3 = (float *) GMT_memory (VNULL, (size_t)((grd_x3.nx + 4) * (grd_x3.ny + 4)), sizeof(float), GMT_program);
GMT_pad[0] = GMT_pad[1] = GMT_pad[2] = GMT_pad[3] = 2;
GMT_boundcond_param_prep (&grd_x, &edgeinfo_x);
GMT_boundcond_param_prep (&grd_x2, &edgeinfo_x2);
GMT_boundcond_param_prep (&grd_x3, &edgeinfo_x3);
GMT_boundcond_set (&grd_x, &edgeinfo_x, GMT_pad, f1);
GMT_boundcond_set (&grd_x2, &edgeinfo_x2, GMT_pad, f2);
GMT_boundcond_set (&grd_x3, &edgeinfo_x3, GMT_pad, f3);
value = 0.0;
GMT_bcr_init (&grd_x, GMT_pad, active, value, &bcr_x);
GMT_bcr_init (&grd_x2, GMT_pad, active, value, &bcr_x2);
GMT_bcr_init (&grd_x3, GMT_pad, active, value, &bcr_x3);
GMT_read_grd (coeff_x, &grd_x, f1, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x2, &grd_x2, f2, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x3, &grd_x3, f3, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
/* Get info from first trace */
ntr = gettra (&tr, 0);
ns = tr.ns;
dt_sec = tr.dt * 0.000001;
scale_factor = tr.scalco;
if (scale_factor < 0.0 ) scale_factor *= -1.0;
if (scale_factor == 0.0 ) scale_factor = 1.0;
if (!getpardouble ("dz",&dz)) dz = 2.0;
if (!getparint ("nz",&nz)) nz = ns;
if ( verbose ) {
fprintf ( stderr, "Output depth sample rate = %f\n", dz );
fprintf ( stderr, "Coordinate scale factor = %f\n", scale_factor );
fprintf ( stderr, "Number of output depth samples per trace = %d\n", nz );
fprintf ( stderr, "number of traces = %d, number of samples per trace = %d\n", ntr, ns );
fprintf ( stderr, "time sample rate (seconds) = %f\n", dt_sec );
}
rewind (stdin);
depth = ealloc1float ( ns );
tr_amp = ealloc1float ( nz );
/* Main loop over traces */
for ( k = 0; k < ntr; ++k ) {
gettr (&tr);
x_loc = tr.sx / scale_factor;
y_loc = tr.sy / scale_factor;
check = 0;
if ( x_loc >= grd_x.x_min && x_loc <= grd_x.x_max && y_loc >= grd_x.y_min && y_loc <= grd_x.y_max ) check = 1;
if ( check ) {
value_coeff_x = GMT_get_bcr_z (&grd_x, x_loc, y_loc, f1, &edgeinfo_x, &bcr_x);
value_coeff_x2 = GMT_get_bcr_z (&grd_x2, x_loc, y_loc, f2, &edgeinfo_x2, &bcr_x2);
value_coeff_x3 = GMT_get_bcr_z (&grd_x3, x_loc, y_loc, f3, &edgeinfo_x3, &bcr_x3);
if ( verbose ) fprintf ( stderr, "Trace num = %d, X-Loc = %f, Y-Loc = %f, X Coefficient = %0.10f, X2 Coefficient = %0.10f, X3 Coefficient = %0.10f\n",
k+1, x_loc, y_loc, value_coeff_x, value_coeff_x2, value_coeff_x3 );
for ( n=0; n < ns; ++n ) {
tr_amp[n] = tr.data[n];
tr_sec = n * dt_sec;
depth[n] = (((value_coeff_x*tr_sec)*weight_x) + ((value_coeff_x2*pow(tr_sec,2))*weight_x2) + ((value_coeff_x3*pow(tr_sec,3))*weight_x3)) * -1.0;
if ( verbose == 2 ) fprintf ( stderr, "Trace no. = %5d, Sample = %5d, TWT (secs.) = %.4f, Depth (feet) = %.4f\n", k, n, tr_sec, depth[n] );
}
for ( n=0; n < nz; ++n ) {
depth_input = n * dz;
intlin ( ns, depth, tr_amp, tr_amp[0], tr_amp[ns-1], 1, &depth_input, &_output );
dtr.data[n] = amp_output;
}
dtr.tracl = tr.tracl;
dtr.tracr = tr.tracr;
dtr.ep = tr.ep;
dtr.ns = nz;
dtr.dt = nint (dz * 1000.0);
dtr.sx = tr.sx;
dtr.sy = tr.sy;
dtr.trid = 1;
dtr.fldr = tr.fldr;
dtr.cdp = tr.cdp ;
puttr (&dtr);
} else {
fprintf ( stderr, "input trace = %d, xloc = %.0f yloc = %.0f is out of bounds\n", k, x_loc, y_loc);
}
}
GMT_free ((void *)f1);
GMT_free ((void *)f2);
GMT_free ((void *)f3);
GMT_end (argc, argv);
free1float (depth);
free1float (tr_amp);
return (0);
}
int main(int argc, char **argv) {
int gelev_vmin, gelev_vmax, selev_vmin, selev_vmax;
int gelev_min, gelev_max, selev_min, selev_max;
int gelev_globalmin, gelev_globalmax, selev_globalmin, selev_globalmax;
int gelev_num, selev_num;
int imin, iminv, ifirst, nz1, nz, ns, ntr, ntrv, nsv;
double dfirst, delrt, delrtv, twt, dt, dtv, factor, z, amp_out;
double *depth, *tr_amp;
float ***velocity;
short verbose;
register int i, j, k, l;
cwp_String vfile;
FILE *fv;
initargs(argc, argv);
requestdoc (0);
if (!getparshort("verbose", &verbose)) verbose = 1;
if (!getparstring("vfile",&vfile)) vfile = "output.su";
ntr = gettra (&tr, 0);
fv = efopen (vfile, "r");
ntrv = fgettra (fv, &vtr, 0);
delrt = tr.delrt;
delrtv = vtr.delrt;
if (!getparint("ns", &ns)) ns = tr.ns;
if (!getparint("nsv", &nsv)) nsv = vtr.ns;
if (!getparint("nz", &nz)) nz=2000;
dt = tr.dt * 0.001;
dtv = vtr.dt * 0.001;
imin = nint ( delrt / dt );
iminv = nint ( delrtv / dtv );
depth = ealloc1double ( ns );
tr_amp = ealloc1double ( ns );
factor = 0.0005;
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "Number of input traces = %d\n", ntr );
fprintf ( stderr, "Number of input samples per trace = %d\n", ns );
fprintf ( stderr, "Number of output samples per trace = %d\n", nz );
fprintf ( stderr, "Sample rate = %f ms.\n", dt );
fprintf ( stderr, "Average velocity SU file name = %s\n", vfile );
fprintf ( stderr, "Number of VAVG input traces = %d\n", ntrv );
fprintf ( stderr, "Number of VAVG input samples per trace = %d\n", nsv );
fprintf ( stderr, "VAVG Sample rate = %f ms.\n", dtv );
fprintf ( stderr, "Input Delay = %f ms., First sample = %d\n", delrt, imin );
fprintf ( stderr, "Velocity Delay = %f ms., First sample = %d\n", delrtv, iminv );
fprintf ( stderr, "\n" );
}
rewind ( fv );
gelev_vmin = selev_vmin = INT_MAX;
gelev_vmax = selev_vmax = INT_MIN;
for ( i = 0; i < ntrv; ++i ) {
fgettr (fv, &vtr);
gelev_vmin = min ( gelev_vmin, vtr.gelev );
gelev_vmax = max ( gelev_vmax, vtr.gelev );
selev_vmin = min ( selev_vmin, vtr.selev );
selev_vmax = max ( selev_vmax, vtr.selev );
}
if ( verbose ) fprintf ( stderr, "VELOCITY DATA - gelev_vmin = %d, gelev_vmax = %d, selev_vmin = %d, selev_vmax = %d\n", gelev_vmin, gelev_vmax, selev_vmin, selev_vmax );
rewind (stdin);
gelev_min = selev_min = INT_MAX;
gelev_max = selev_max = INT_MIN;
for ( i = 0; i < ntr; ++i ) {
gettr (&tr);
gelev_min = min ( gelev_min, tr.gelev );
gelev_max = max ( gelev_max, tr.gelev );
selev_min = min ( selev_min, tr.selev );
selev_max = max ( selev_max, tr.selev );
}
if ( verbose ) fprintf ( stderr, "INPUT DATA - gelev_min = %d, gelev_max = %d, selev_min = %d, selev_max = %d\n", gelev_min, gelev_max, selev_min, selev_max );
gelev_globalmin = max ( gelev_min, gelev_vmin );
selev_globalmin = max ( selev_min, selev_vmin );
gelev_globalmax = min ( gelev_max, gelev_vmax );
selev_globalmax = min ( selev_max, selev_vmax );
gelev_num = gelev_globalmax - gelev_globalmin + 1;
selev_num = selev_globalmax - selev_globalmin + 1;
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "gelev_globalmin = %d, gelev_globalmax = %d, selev_globalmin = %d, selev_globalmax = %d\n", gelev_globalmin, gelev_globalmax, selev_globalmin, selev_globalmax );
fprintf ( stderr, "gelev_num = %d, selev_num = %d\n", gelev_num, selev_num );
}
velocity = ealloc3float ( nsv, selev_num, gelev_num );
rewind ( fv );
ifirst = 0;
dfirst = 9999999999999999.9;
for ( k = 0; k < ntrv; ++k ) {
fgettr (fv, &vtr);
if ( vtr.gelev >= gelev_globalmin && vtr.gelev <= gelev_globalmax && vtr.selev >= selev_globalmin && vtr.selev <= selev_globalmax ) {
i = vtr.gelev - gelev_globalmin;
j = vtr.selev - selev_globalmin;
memcpy( (void *) &velocity[i][j][0], (const void *) &vtr.data, nsv * FSIZE );
dfirst = min ( dfirst, velocity[i][j][0] * delrtv * factor );
}
}
efclose (fv);
ifirst = nint ( dfirst / dt );
nz1 = nz - ifirst;
if ( verbose ) fprintf ( stderr, "ifirst = %d, dfirst = %f, nz1 = %d\n", ifirst, dfirst, nz1 );
float zero;
double depth_max;
zero = 0.0;
rewind (stdin);
for ( l = 0; l < ntr; ++l ) {
gettr (&tr);
if ( tr.gelev >= gelev_globalmin && tr.gelev <= gelev_globalmax && tr.selev >= selev_globalmin && tr.selev <= selev_globalmax ) {
i = tr.gelev - gelev_globalmin;
j = tr.selev - selev_globalmin;
for ( k = 0; k < nsv; ++k ) {
twt = ( k * dtv ) + delrtv;
tr_amp[k] = tr.data[k+iminv];
depth[k] = velocity[i][j][k] * twt * factor;
}
depth_max = depth[nsv-1];
fprintf ( stderr, "trace number = %5d, depth_max = %f\n", l, depth_max );
for ( k=ifirst; k < nz1; ++k ) {
z = k * dt;
if ( z <= depth_max ) {
dintlin ( nsv, depth, tr_amp, tr_amp[0], tr_amp[nsv-1], 1, &z, &_out );
tr.data[k-ifirst] = (float) amp_out;
} else {
tr.data[k-ifirst] = zero;
}
}
tr.trid = 1;
tr.ns = nsv;
tr.delrt = nint ( dfirst );
tr.dt = nint(dt*1000);
puttr (&tr);
}
}
free1double (tr_amp);
free1double (depth);
free3float (velocity);
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
char *coeff_x, *coeff_x2, file[BUFSIZ];
struct GRD_HEADER grd_x, grd_x2;
struct GMT_EDGEINFO edgeinfo_x, edgeinfo_x2;
struct GMT_BCR bcr_x, bcr_x2;
int *idx, n, ns, ntr, istart, istop, index;
float scale_factor;
double *x, *y, dt, zero, factor, rns;
double ri, **A, *B, d, sum;
double water_depth, error, rx, ry;
double value_coeff_x, value_coeff_x2, water_velocity, x_loc, y_loc;
short check, verbose, intercept;
register int i, j, k, l;
initargs(argc, argv);
argc = GMT_begin (argc, argv);
if (!getparint("n", &n)) n = 4;
if (!getparshort("intercept", &intercept)) intercept = 0;
if (!getparshort("verbose", &verbose)) verbose = 1;
if (!getparstring("coeff_x", &coeff_x)) coeff_x="/home/user/Field/GRIDS/wb.twt.sm2500.new.grd";
if (!getparstring("coeff_x2", &coeff_x2)) coeff_x2="/home/user/Field/HORIZONS/DC_Base_Reservoir.reform.dat.trimmed.sample.smooth.grd";
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "WB TWT GMT grid file name = %s\n", coeff_x );
fprintf ( stderr, "Bottom Horizon GMT grid file name = %s\n", coeff_x2 );
}
GMT_boundcond_init (&edgeinfo_x);
GMT_boundcond_init (&edgeinfo_x2);
GMT_grd_init (&grd_x, argc, argv, FALSE);
GMT_grd_init (&grd_x2, argc, argv, FALSE);
if (GMT_read_grd_info (coeff_x, &grd_x)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x2, &grd_x2)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
f1 = (float *) GMT_memory (VNULL, (size_t)((grd_x.nx + 4) * (grd_x.ny + 4)), sizeof(float), GMT_program);
f2 = (float *) GMT_memory (VNULL, (size_t)((grd_x2.nx + 4) * (grd_x2.ny + 4)), sizeof(float), GMT_program);
GMT_pad[0] = GMT_pad[1] = GMT_pad[2] = GMT_pad[3] = 2;
GMT_boundcond_param_prep (&grd_x, &edgeinfo_x);
GMT_boundcond_param_prep (&grd_x2, &edgeinfo_x2);
GMT_boundcond_set (&grd_x, &edgeinfo_x, GMT_pad, f1);
GMT_boundcond_set (&grd_x2, &edgeinfo_x2, GMT_pad, f2);
GMT_bcr_init (&grd_x, GMT_pad, BCR_BSPLINE, 1, &bcr_x);
GMT_bcr_init (&grd_x2, GMT_pad, BCR_BSPLINE, 1, &bcr_x2);
GMT_read_grd (coeff_x, &grd_x, f1, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x2, &grd_x2, f2, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
ntr = gettra (&tr, 0);
ns = tr.ns;
dt = tr.dt * 0.001;
scale_factor = tr.scalco;
if (scale_factor < 0.0 ) scale_factor *= -1.0;
if (scale_factor == 0.0 ) scale_factor = 1.0;
zero = 0.0;
factor = 0.0005;
rns = ns;
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "Degree of Polynomial = %d\n", n );
fprintf ( stderr, "Intercept = %d\n", intercept );
fprintf ( stderr, "Number of input traces = %d\n", ntr );
fprintf ( stderr, "Number of samples per trace = %d\n", ns );
fprintf ( stderr, "Sample rate = %f ms.\n", dt );
fprintf ( stderr, "Scale Factor for X and Y Coordinates = %f\n", scale_factor );
fprintf ( stderr, "\n" );
}
A = dmatrix (1,n,1,n);
B = dvector (1,n);
x = ealloc1double (ns);
y = ealloc1double (ns);
rewind (stdin);
for (l=0;l<ntr;l++) {
gettr (&tr);
x_loc = tr.sx = nint ( tr.sx / scale_factor );
y_loc = tr.sy = nint ( tr.sy / scale_factor );
check = 0;
istop = ns;
if ( x_loc >= grd_x.x_min && x_loc <= grd_x.x_max && y_loc >= grd_x.y_min && y_loc <= grd_x.y_max ) check = 1;
if ( check ) {
value_coeff_x = GMT_get_bcr_z (&grd_x, x_loc, y_loc, f1, &edgeinfo_x, &bcr_x);
value_coeff_x2 = GMT_get_bcr_z (&grd_x2, x_loc, y_loc, f2, &edgeinfo_x2, &bcr_x2);
if (GMT_is_dnan (value_coeff_x) || GMT_is_dnan (value_coeff_x2)) {
check = 0;
} else {
if ( value_coeff_x < 0.0 ) value_coeff_x *= -1.0;
if ( value_coeff_x2 < 0.0 ) value_coeff_x2 *= -1.0;
value_coeff_x2 += 100.0;
istop = nint ( value_coeff_x2 / dt );
istop = max ( min ( istop, ns ), 0 );
if ( tr.wevel > 0 ) {
water_velocity = tr.wevel;
} else {
index = max ( min ( nint(value_coeff_x/dt), ns ), 0 );
water_velocity = tr.data[index];
}
water_depth = water_velocity * value_coeff_x * factor;
}
}
if ( verbose == 3 && check ) {
fprintf ( stderr, "input trace = %6d, xloc = %8.2f yloc = %8.2f, WB TWT = %8.2f ms., WB Depth = %10.4f meters, Water Velocity = %8.2f mps, Bottom Horizon = %8.2f\n",
l, x_loc, y_loc, value_coeff_x, water_depth, water_velocity, value_coeff_x2 );
}
if ( check ) {
for (k=0;k<=istop;k++) {
x[k] = k * dt;
y[k] = ( ( tr.data[k] * x[k] ) * factor ) - water_depth;
x[k] -= value_coeff_x;
}
istart = 0;
for (k=0;k<=istop;k++) {
if ( x[k] >= zero && y[k] >= zero ) {
istart = k;
break;
}
}
if ( verbose == 3 ) fprintf ( stderr, "istart = %d, istop = %d\n", istart, istop );
for (i=1;i<=n;i++) {
for (j=1;j<=n;j++) {
sum = zero;
ri = i+j-2;
for (k=istart;k<=istop;k++) sum += pow ( x[k], ri );
if (i>1&&j==1&&intercept==0) sum = zero;
A[i][j] = sum;
}
}
for (i=1;i<=n;i++) {
sum = zero;
ri = i - 1;
for (j=istart;j<=istop;j++) sum += pow( x[j], ri ) * y[j];
B[i] = sum;
}
idx = ivector (1, n);
ludcmp ( A, n, idx, &d );
lubksb ( A, n, idx, B );
error = ry = zero;
if ( intercept ) {
for ( i=istart; i<=istop; i++ ) {
rx = x[i];
ry = B[1];
for (j=2;j<=n;j++) ry += B[j] * pow ( rx, j-1 );
error += abs ( ry - y[i] );
if ( verbose == 2 ) fprintf ( stderr, "%-6d %12.2f %12.2f %12.2f %12.4f %12.4f\n", i, rx, y[i], ry, ry - y[i], error );
}
} else {
for ( i=istart; i<=istop; i++ ) {
rx = x[i];
ry = zero;
for (j=1;j<=n;j++) ry += B[j] * pow ( rx, j-1 );
error += abs ( ry - y[i] );
if ( verbose == 2 ) fprintf ( stderr, "%-6d %12.2f %12.2f %12.2f %12.4f %12.4f\n", i, rx, y[i], ry, ry - y[i], error );
}
}
rns = istop - istart + 1;
if ( verbose ) {
if ( intercept ) {
for (i=1;i<=n;i++) printf ( "coefficient number = %5d, Solution vector = %30.25f, Average Error = %12.4f\n", i, B[i], error / rns );
} else {
for (i=2;i<=n;i++) printf ( "coefficient number = %5d, Solution vector = %30.25f, Average Error = %12.4f\n", i, B[i], error / rns );
}
} else {
printf ( "%-12.2f %12.2f ", x_loc, y_loc );
if ( intercept ) {
for (i=1;i<n;i++) printf ( "%30.25f ", B[i] );
} else {
for (i=2;i<n;i++) printf ( "%30.25f ", B[i] );
}
printf ( "%30.25f %12.4f %12.4f %12.4f %12.4f %12.4f\n", B[n], error / rns, water_velocity, water_depth, value_coeff_x, value_coeff_x2 );
}
}
}
free_dmatrix (A,1,n,1,n);
free_dvector (B,1,n);
free1double (x);
free1double (y);
GMT_free ((void *)f1);
GMT_free ((void *)f2);
GMT_end (argc, argv);
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
char *coeff_x, *coeff_x2, *coeff_x3, *coeff_x4, file[BUFSIZ];
struct GRD_HEADER grd_x, grd_x2, grd_x3, grd_x4;
struct GMT_EDGEINFO edgeinfo_x, edgeinfo_x2, edgeinfo_x3, edgeinfo_x4;
struct GMT_BCR bcr_x, bcr_x2, bcr_x3, bcr_x4;
double x_loc, y_loc, value_coeff_x, value_coeff_x2, value_coeff_x3, value_coeff_x4;
char temp[256];
cwp_String pfile;
FILE *fpp;
short verbose, check;
int kount, nump1;
double sum, error1, sign;
double delta, thresh;
double *vzero_opt, *k_opt;
double *datain, *samp, *xloc_array, *yloc_array;
double depth_water, factor, num, sample;
double vzero, k;
double *wb_twt_array, *wb_z_array;
double error, x, y, zero;
register int i;
initargs(argc, argv);
argc = GMT_begin (argc, argv);
if (!getparstring("pfile",&pfile)) pfile = "tops.lis";
if (!getparshort("verbose", &verbose)) verbose = 1;
if (!getpardouble("delta", &delta)) delta = 0.00001;
if (!getpardouble("thresh", &thresh)) thresh = 0.01;
zero = 0.0;
if (!getparstring("coeff_x", &coeff_x)) coeff_x="wb.twt.grd";
if (!getparstring("coeff_x2", &coeff_x2)) coeff_x2="wvavg.dat.trimmed.sample.smooth.grd";
if (!getparstring("coeff_x3", &coeff_x3)) coeff_x3="vzero.seismic.dat.trimmed.sample.smooth.grd";
if (!getparstring("coeff_x4", &coeff_x4)) coeff_x4="k.seismic.dat.trimmed.sample.smooth.grd";
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "WB TWT (ms.) GMT grid file name = %s\n", coeff_x );
fprintf ( stderr, "WB VAVG (m) GMT grid file name = %s\n", coeff_x2 );
fprintf ( stderr, "Seismic VZERO GMT grid file name = %s\n", coeff_x3 );
fprintf ( stderr, "Seismic K GMT grid file name = %s\n", coeff_x4 );
fprintf ( stderr, "Delta = %.10f\n", delta );
fprintf ( stderr, "Threshold = %f\n", thresh );
}
GMT_boundcond_init (&edgeinfo_x);
GMT_boundcond_init (&edgeinfo_x2);
GMT_boundcond_init (&edgeinfo_x3);
GMT_boundcond_init (&edgeinfo_x4);
GMT_grd_init (&grd_x, argc, argv, FALSE);
GMT_grd_init (&grd_x2, argc, argv, FALSE);
GMT_grd_init (&grd_x3, argc, argv, FALSE);
GMT_grd_init (&grd_x4, argc, argv, FALSE);
if (GMT_read_grd_info (coeff_x, &grd_x)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x2, &grd_x2)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x3, &grd_x3)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_x4, &grd_x4)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
f1 = (float *) GMT_memory (VNULL, (size_t)((grd_x.nx + 4) * (grd_x.ny + 4)), sizeof(float), GMT_program);
f2 = (float *) GMT_memory (VNULL, (size_t)((grd_x2.nx + 4) * (grd_x2.ny + 4)), sizeof(float), GMT_program);
f3 = (float *) GMT_memory (VNULL, (size_t)((grd_x3.nx + 4) * (grd_x3.ny + 4)), sizeof(float), GMT_program);
f4 = (float *) GMT_memory (VNULL, (size_t)((grd_x4.nx + 4) * (grd_x4.ny + 4)), sizeof(float), GMT_program);
GMT_pad[0] = GMT_pad[1] = GMT_pad[2] = GMT_pad[3] = 2;
GMT_boundcond_param_prep (&grd_x, &edgeinfo_x);
GMT_boundcond_param_prep (&grd_x2, &edgeinfo_x2);
GMT_boundcond_param_prep (&grd_x3, &edgeinfo_x3);
GMT_boundcond_param_prep (&grd_x4, &edgeinfo_x4);
GMT_boundcond_set (&grd_x, &edgeinfo_x, GMT_pad, f1);
GMT_boundcond_set (&grd_x2, &edgeinfo_x2, GMT_pad, f2);
GMT_boundcond_set (&grd_x3, &edgeinfo_x3, GMT_pad, f3);
GMT_boundcond_set (&grd_x4, &edgeinfo_x4, GMT_pad, f4);
GMT_bcr_init (&grd_x, GMT_pad, BCR_BSPLINE, 1, &bcr_x);
GMT_bcr_init (&grd_x2, GMT_pad, BCR_BSPLINE, 1, &bcr_x2);
GMT_bcr_init (&grd_x3, GMT_pad, BCR_BSPLINE, 1, &bcr_x3);
GMT_bcr_init (&grd_x4, GMT_pad, BCR_BSPLINE, 1, &bcr_x4);
GMT_read_grd (coeff_x, &grd_x, f1, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x2, &grd_x2, f2, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x3, &grd_x3, f3, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_x4, &grd_x4, f4, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
fpp = efopen (pfile, "r");
kount = 0;
while (NULL != fgets ( temp, sizeof(temp), fpp )) {
++kount;
(void) sscanf ( ((&(temp[0]))), "%lf%lf%lf%lf", &x_loc, &y_loc, &num, &sample );
}
if ( verbose != 0) {
fprintf (stderr,"\n");
fprintf (stderr,"Data file name = %s, number of input samples = %d\n", pfile, kount);
fprintf (stderr,"\n");
}
samp = ealloc1double ( kount );
datain = ealloc1double ( kount );
xloc_array = ealloc1double ( kount );
yloc_array = ealloc1double ( kount );
vzero_opt = ealloc1double ( kount );
k_opt = ealloc1double ( kount );
wb_twt_array = ealloc1double ( kount );
wb_z_array = ealloc1double ( kount );
rewind ( fpp );
kount = -1;
while (NULL != fgets ( temp, sizeof(temp), fpp )) {
++kount;
(void) sscanf ( ((&(temp[0]))), "%lf%lf%lf%lf", &x_loc, &y_loc, &num, &sample );
xloc_array[kount] = x_loc;
yloc_array[kount] = y_loc;
samp[kount] = num;
datain[kount] = sample;
if ( verbose == 2 ) fprintf ( stderr, "kount = %5d, x_loc = %12.2f, y_loc = %12.2f, num = %8.2f, sample = %8.2f\n", kount, xloc_array[kount], yloc_array[kount], samp[kount], datain[kount] );
}
if ( verbose == 2 ) fprintf ( stderr, "\n" );
efclose (fpp);
factor = 0.0005;
nump1 = kount + 1;
depth_water = error = zero;
for ( i=0; i<=kount; i++ ) {
check = 0;
x_loc = xloc_array[i];
y_loc = yloc_array[i];
if ( x_loc >= grd_x.x_min && x_loc <= grd_x.x_max && y_loc >= grd_x.y_min && y_loc <= grd_x.y_max ) check = 1;
if ( check ) {
value_coeff_x = GMT_get_bcr_z (&grd_x, x_loc, y_loc, f1, &edgeinfo_x, &bcr_x);
value_coeff_x2 = GMT_get_bcr_z (&grd_x2, x_loc, y_loc, f2, &edgeinfo_x2, &bcr_x2);
value_coeff_x3 = GMT_get_bcr_z (&grd_x3, x_loc, y_loc, f3, &edgeinfo_x3, &bcr_x3);
value_coeff_x4 = GMT_get_bcr_z (&grd_x4, x_loc, y_loc, f4, &edgeinfo_x4, &bcr_x4);
if (GMT_is_dnan (value_coeff_x) || GMT_is_dnan (value_coeff_x2) || GMT_is_dnan (value_coeff_x3) || GMT_is_dnan (value_coeff_x4) ) {
check = 0;
} else {
if ( value_coeff_x < 0.0 ) value_coeff_x *= -1.0;
if ( value_coeff_x2 < 0.0 ) value_coeff_x2 *= -1.0;
if ( value_coeff_x3 < 0.0 ) value_coeff_x3 *= -1.0;
if ( value_coeff_x4 < 0.0 ) value_coeff_x4 *= -1.0;
samp[i] -= value_coeff_x;
depth_water = value_coeff_x * value_coeff_x2 * factor;
datain[i] -= depth_water;
wb_twt_array[i] = value_coeff_x;
wb_z_array[i] = depth_water;
if ( verbose == 3 ) fprintf ( stderr, "num = %5d, xloc = %10.2f yloc = %10.2f, WB TWT = %8.2f ms., WB Depth = %8.2f m., WB VEL = %8.2f mps., Vzero = %20.15f, K = %20.15f\n",
i, x_loc, y_loc, value_coeff_x, depth_water, value_coeff_x2, value_coeff_x3, value_coeff_x4 );
vzero_opt[i] = value_coeff_x3;
k_opt[i] = value_coeff_x4;
}
}
}
if ( verbose == 3 ) fprintf ( stderr, "\n" );
sum = zero;
for ( i=0; i<=kount; i++ ) {
vzero = vzero_opt[i];
k = k_opt[i];
x = samp[i];
y = ( vzero / k ) * ( exp ( k * x * factor ) - 1.0 );
error += abs ( y - datain[i] );
if ( verbose == 3 ) fprintf ( stderr, "%-5d %12.2f %12.2f %12.2f %12.4f %12.4f\n", i, x, datain[i], y, y - datain[i], error );
sign = 1.0;
error = error1 = y - datain[i];
for (;;) {
if ( abs(error1) < thresh ) break;
vzero = vzero_opt[i];
k += ( delta * sign );
x = samp[i];
y = ( vzero / k ) * ( exp ( k * x * factor ) - 1.0 );
error1 = y - datain[i];
if ( verbose == 2 ) fprintf ( stderr, "%-5d %12.2f %12.2f %12.2f %12.4f\n", i, x, datain[i], y, error1 );
if ( (error1 > zero && error1 > error) || (error1 < zero && error1 < error) ) sign *= -1.0;
}
sum += abs ( y - datain[i] );
if ( verbose ) {
fprintf ( stderr, "%-5d %12.2f %12.2f %12.2f %12.4f %12.4f\n", i, x, datain[i], y, y - datain[i], sum );
fprintf ( stderr, "%12.2f %12.2f ", xloc_array[i], yloc_array[i] );
fprintf ( stderr, "%30.25f %30.25f %8.2f %8.2f %8.2f\n", vzero, k, wb_twt_array[i], wb_z_array[i], sum / (float) nump1 );
}
printf ( "%12.2f %12.2f ", xloc_array[i], yloc_array[i] );
printf ( "%30.25f %30.25f %8.2f %8.2f %8.2f\n", vzero, k, wb_twt_array[i], wb_z_array[i], sum / (float) nump1 );
}
free1double (samp);
free1double (datain);
free1double (xloc_array);
free1double (yloc_array);
free1double (vzero_opt);
free1double (k_opt);
free1double (wb_twt_array);
free1double (wb_z_array);
GMT_free ((void *)f1);
GMT_free ((void *)f2);
GMT_free ((void *)f3);
GMT_free ((void *)f4);
GMT_end (argc, argv);
return EXIT_SUCCESS;
}
int main (int argc, char **argv) {
char file[BUFSIZ];
char *coeff_top_k, *coeff_bottom_k;
char *coeff_wb_twt, *coeff_top_twt, *coeff_middle_twt, *coeff_bottom_twt;
char *coeff_middle_vint, *coeff_bottom_vint, *coeff_campan_vint;
char *coeff_top_z, *coeff_bottom_z;
struct GRD_HEADER grd_top_k, grd_bottom_k;
struct GRD_HEADER grd_wb_twt, grd_top_twt, grd_middle_twt, grd_bottom_twt;
struct GRD_HEADER grd_middle_vint, grd_bottom_vint, grd_campan_vint;
struct GRD_HEADER grd_top_z, grd_bottom_z;
struct GMT_EDGEINFO edgeinfo_top_k, edgeinfo_bottom_k;
struct GMT_EDGEINFO edgeinfo_wb_twt, edgeinfo_top_twt, edgeinfo_middle_twt, edgeinfo_bottom_twt;
struct GMT_EDGEINFO edgeinfo_middle_vint, edgeinfo_bottom_vint, edgeinfo_campan_vint;
struct GMT_EDGEINFO edgeinfo_top_z, edgeinfo_bottom_z;
struct GMT_BCR bcr_top_k, bcr_bottom_k;
struct GMT_BCR bcr_wb_twt, bcr_top_twt, bcr_middle_twt, bcr_bottom_twt;
struct GMT_BCR bcr_middle_vint, bcr_bottom_vint, bcr_campan_vint;
struct GMT_BCR bcr_top_z, bcr_bottom_z;
double value_coeff_top_k, value_coeff_bottom_k;
double value_coeff_wb_twt, value_coeff_top_twt, value_coeff_middle_twt, value_coeff_bottom_twt;
double value_coeff_middle_vint, value_coeff_bottom_vint, value_coeff_campan_vint;
double value_coeff_top_z, value_coeff_bottom_z;
short verbose;
int scalar, nz, ntr, ns;
double water_depth, vwater, ratio, factor1, dz, x_loc, y_loc;
double tr_msec, tr_msec_orig, dt_msec, depth_input, amp_output;
double delrt_depth, delta_twt, delta_k, gradient, K;
double *tr_amp, *depth;
register int k, n;
initargs(argc, argv);
argc = GMT_begin (argc, argv);
if (!getparstring ("coeff_top_k", &coeff_top_k)) coeff_top_k = "/home/user/FIELD.new/PICKS/DEPTH_GRIDS/below.ml.K.grd";
if (!getparstring ("coeff_bottom_k", &coeff_bottom_k)) coeff_bottom_k = "/home/user/FIELD.new/PICKS/DEPTH_GRIDS/bottom.K.grd";
if (!getparstring ("coeff_wb_twt", &coeff_wb_twt)) coeff_wb_twt = "/home/user/FIELD.new/PICKS/wb.twt.grd";
if (!getparstring ("coeff_top_twt", &coeff_top_twt)) coeff_top_twt = "/home/user/FIELD.new/PICKS/TWT_GRIDS/01_FIELD_Top_Reservoir_twt.reform.dat.trimmed.grd";
if (!getparstring ("coeff_middle_twt", &coeff_middle_twt)) coeff_middle_twt = "/home/user/FIELD.new/PICKS/TWT_GRIDS/06_FIELD_C_top_twt.reform.dat.trimmed.grd";
if (!getparstring ("coeff_bottom_twt", &coeff_bottom_twt)) coeff_bottom_twt = "/home/user/FIELD.new/PICKS/TWT_GRIDS/10_FIELD_80MaSB_twt.reform.dat.trimmed.grd";
if (!getparstring ("coeff_middle_vint", &coeff_middle_vint)) coeff_middle_vint = "/home/user/FIELD.new/PICKS/VINT_GRIDS/vint.top_res.C_Sand.mps.filter.grd";
if (!getparstring ("coeff_bottom_vint", &coeff_bottom_vint)) coeff_bottom_vint = "/home/user/FIELD.new/PICKS/VINT_GRIDS/vint.C_Sand.80MaSB.mps.filter.grd";
if (!getparstring ("coeff_campan_vint", &coeff_campan_vint)) coeff_campan_vint = "/home/user/FIELD.new/PICKS/VINT_GRIDS/vint.top_res.80MaSB.mps.filter.grd";
if (!getparstring ("coeff_top_z", &coeff_top_z)) coeff_top_z = "/home/user/FIELD.new/PICKS/DEPTH_GRIDS/01_FIELD_Top_Reservoir.depth.new.grd";
if (!getparstring ("coeff_bottom_z", &coeff_bottom_z)) coeff_bottom_z = "/home/user/FIELD.new/PICKS/DEPTH_GRIDS/10_FIELD_80MaSB.depth.new.grd";
if (!getparshort ("verbose", &verbose)) verbose = 0;
if ( verbose ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "Top_K - GMT grid file name = %s\n", coeff_top_k );
fprintf ( stderr, "Bottom_K - GMT grid file name = %s\n", coeff_bottom_k );
fprintf ( stderr, "WB_TWT - GMT grid file name = %s\n", coeff_wb_twt );
fprintf ( stderr, "TOP_TWT - GMT grid file name = %s\n", coeff_top_twt );
fprintf ( stderr, "MIDDLE_TWT - GMT grid file name = %s\n", coeff_middle_twt );
fprintf ( stderr, "BOTTOM_TWT - GMT grid file name = %s\n", coeff_bottom_twt );
fprintf ( stderr, "MIDDLE_VINT - GMT grid file name = %s\n", coeff_middle_vint );
fprintf ( stderr, "BOTTOM_VINT - GMT grid file name = %s\n", coeff_bottom_vint );
fprintf ( stderr, "CAMPAN_VINT - GMT grid file name = %s\n", coeff_campan_vint );
fprintf ( stderr, "TOP_Z - GMT grid file name = %s\n", coeff_top_z );
fprintf ( stderr, "BOTTOM_Z - GMT grid file name = %s\n", coeff_bottom_z );
fprintf ( stderr, "\n" );
}
GMT_boundcond_init (&edgeinfo_top_k);
GMT_boundcond_init (&edgeinfo_bottom_k);
GMT_boundcond_init (&edgeinfo_wb_twt);
GMT_boundcond_init (&edgeinfo_top_twt);
GMT_boundcond_init (&edgeinfo_middle_twt);
GMT_boundcond_init (&edgeinfo_bottom_twt);
GMT_boundcond_init (&edgeinfo_middle_vint);
GMT_boundcond_init (&edgeinfo_bottom_vint);
GMT_boundcond_init (&edgeinfo_campan_vint);
GMT_boundcond_init (&edgeinfo_top_z);
GMT_boundcond_init (&edgeinfo_bottom_z);
GMT_grd_init (&grd_top_k, argc, argv, FALSE);
GMT_grd_init (&grd_bottom_k, argc, argv, FALSE);
GMT_grd_init (&grd_wb_twt, argc, argv, FALSE);
GMT_grd_init (&grd_top_twt, argc, argv, FALSE);
GMT_grd_init (&grd_middle_twt, argc, argv, FALSE);
GMT_grd_init (&grd_bottom_twt, argc, argv, FALSE);
GMT_grd_init (&grd_middle_vint, argc, argv, FALSE);
GMT_grd_init (&grd_bottom_vint, argc, argv, FALSE);
GMT_grd_init (&grd_campan_vint, argc, argv, FALSE);
GMT_grd_init (&grd_top_z, argc, argv, FALSE);
GMT_grd_init (&grd_bottom_z, argc, argv, FALSE);
if (GMT_read_grd_info (coeff_top_k, &grd_top_k)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_bottom_k, &grd_bottom_k)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_wb_twt, &grd_wb_twt)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_top_twt, &grd_top_twt)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_middle_twt, &grd_middle_twt)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_bottom_twt, &grd_bottom_twt)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_middle_vint, &grd_middle_vint)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_bottom_vint, &grd_bottom_vint)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_campan_vint, &grd_campan_vint)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_top_z, &grd_top_z)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
if (GMT_read_grd_info (coeff_bottom_z, &grd_bottom_z)) fprintf (stderr, "%s: Error opening file %s\n", GMT_program, file);
f_top_k = (float *) GMT_memory (VNULL, (size_t)((grd_top_k.nx + 4) * (grd_top_k.ny + 4)), sizeof(float), GMT_program);
f_bottom_k = (float *) GMT_memory (VNULL, (size_t)((grd_bottom_k.nx + 4) * (grd_bottom_k.ny + 4)), sizeof(float), GMT_program);
f_wb_twt = (float *) GMT_memory (VNULL, (size_t)((grd_wb_twt.nx + 4) * (grd_wb_twt.ny + 4)), sizeof(float), GMT_program);
f_top_twt = (float *) GMT_memory (VNULL, (size_t)((grd_top_twt.nx + 4) * (grd_top_twt.ny + 4)), sizeof(float), GMT_program);
f_middle_twt = (float *) GMT_memory (VNULL, (size_t)((grd_middle_twt.nx + 4) * (grd_middle_twt.ny + 4)), sizeof(float), GMT_program);
f_bottom_twt = (float *) GMT_memory (VNULL, (size_t)((grd_bottom_twt.nx + 4) * (grd_bottom_twt.ny + 4)), sizeof(float), GMT_program);
f_middle_vint = (float *) GMT_memory (VNULL, (size_t)((grd_middle_vint.nx + 4) * (grd_middle_vint.ny + 4)), sizeof(float), GMT_program);
f_bottom_vint = (float *) GMT_memory (VNULL, (size_t)((grd_bottom_vint.nx + 4) * (grd_bottom_vint.ny + 4)), sizeof(float), GMT_program);
f_campan_vint = (float *) GMT_memory (VNULL, (size_t)((grd_campan_vint.nx + 4) * (grd_campan_vint.ny + 4)), sizeof(float), GMT_program);
f_top_z = (float *) GMT_memory (VNULL, (size_t)((grd_top_z.nx + 4) * (grd_top_z.ny + 4)), sizeof(float), GMT_program);
f_bottom_z = (float *) GMT_memory (VNULL, (size_t)((grd_bottom_z.nx + 4) * (grd_bottom_z.ny + 4)), sizeof(float), GMT_program);
GMT_pad[0] = GMT_pad[1] = GMT_pad[2] = GMT_pad[3] = 2;
GMT_boundcond_param_prep (&grd_top_k, &edgeinfo_top_k);
GMT_boundcond_param_prep (&grd_bottom_k, &edgeinfo_bottom_k);
GMT_boundcond_param_prep (&grd_wb_twt, &edgeinfo_wb_twt);
GMT_boundcond_param_prep (&grd_top_twt, &edgeinfo_top_twt);
GMT_boundcond_param_prep (&grd_middle_twt, &edgeinfo_middle_twt);
GMT_boundcond_param_prep (&grd_bottom_twt, &edgeinfo_bottom_twt);
GMT_boundcond_param_prep (&grd_middle_vint, &edgeinfo_middle_vint);
GMT_boundcond_param_prep (&grd_bottom_vint, &edgeinfo_bottom_vint);
GMT_boundcond_param_prep (&grd_campan_vint, &edgeinfo_campan_vint);
GMT_boundcond_param_prep (&grd_top_z, &edgeinfo_top_z);
GMT_boundcond_param_prep (&grd_bottom_z, &edgeinfo_bottom_z);
GMT_boundcond_set (&grd_top_k, &edgeinfo_top_k, GMT_pad, f_top_k);
GMT_boundcond_set (&grd_bottom_k, &edgeinfo_bottom_k, GMT_pad, f_bottom_k);
GMT_boundcond_set (&grd_wb_twt, &edgeinfo_wb_twt, GMT_pad, f_wb_twt);
GMT_boundcond_set (&grd_top_twt, &edgeinfo_top_twt, GMT_pad, f_top_twt);
GMT_boundcond_set (&grd_middle_twt, &edgeinfo_middle_twt, GMT_pad, f_middle_twt);
GMT_boundcond_set (&grd_bottom_twt, &edgeinfo_bottom_twt, GMT_pad, f_bottom_twt);
GMT_boundcond_set (&grd_middle_vint, &edgeinfo_middle_vint, GMT_pad, f_middle_vint);
GMT_boundcond_set (&grd_bottom_vint, &edgeinfo_bottom_vint, GMT_pad, f_bottom_vint);
GMT_boundcond_set (&grd_campan_vint, &edgeinfo_campan_vint, GMT_pad, f_campan_vint);
GMT_boundcond_set (&grd_top_z, &edgeinfo_top_z, GMT_pad, f_top_z);
GMT_boundcond_set (&grd_bottom_z, &edgeinfo_bottom_z, GMT_pad, f_bottom_z);
GMT_bcr_init (&grd_top_k, GMT_pad, BCR_BSPLINE, 1, &bcr_top_k);
GMT_bcr_init (&grd_bottom_k, GMT_pad, BCR_BSPLINE, 1, &bcr_bottom_k);
GMT_bcr_init (&grd_wb_twt, GMT_pad, BCR_BSPLINE, 1, &bcr_wb_twt);
GMT_bcr_init (&grd_top_twt, GMT_pad, BCR_BSPLINE, 1, &bcr_top_twt);
GMT_bcr_init (&grd_middle_twt, GMT_pad, BCR_BSPLINE, 1, &bcr_middle_twt);
GMT_bcr_init (&grd_bottom_twt, GMT_pad, BCR_BSPLINE, 1, &bcr_bottom_twt);
GMT_bcr_init (&grd_middle_vint, GMT_pad, BCR_BSPLINE, 1, &bcr_middle_vint);
GMT_bcr_init (&grd_bottom_vint, GMT_pad, BCR_BSPLINE, 1, &bcr_bottom_vint);
GMT_bcr_init (&grd_campan_vint, GMT_pad, BCR_BSPLINE, 1, &bcr_campan_vint);
GMT_bcr_init (&grd_top_z, GMT_pad, BCR_BSPLINE, 1, &bcr_top_z);
GMT_bcr_init (&grd_bottom_z, GMT_pad, BCR_BSPLINE, 1, &bcr_bottom_z);
GMT_read_grd (coeff_top_k, &grd_top_k, f_top_k, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_bottom_k, &grd_bottom_k, f_bottom_k, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_wb_twt, &grd_wb_twt, f_wb_twt, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_top_twt, &grd_top_twt, f_top_twt, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_middle_twt, &grd_middle_twt, f_middle_twt, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_bottom_twt, &grd_bottom_twt, f_bottom_twt, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_middle_vint, &grd_middle_vint, f_middle_vint, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_bottom_vint, &grd_bottom_vint, f_bottom_vint, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_campan_vint, &grd_campan_vint, f_campan_vint, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_top_z, &grd_top_z, f_top_z, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
GMT_read_grd (coeff_bottom_z, &grd_bottom_z, f_bottom_z, 0.0, 0.0, 0.0, 0.0, GMT_pad, FALSE);
/* Get info from first trace */
ntr = gettra (&tr, 0);
ns = tr.ns;
scalar = abs ( tr.scalel );
if ( scalar == 0 ) scalar = 1;
dt_msec = tr.dt * 0.001;
if (!getpardouble ("dz",&dz)) dz = 1;
if (!getpardouble ("vwater",&vwater)) vwater = 1452.05;
if (!getparint ("nz",&nz)) nz = ns;
if ( verbose ) {
fprintf ( stderr, "Output depth sample rate (dz) = %f\n", dz );
fprintf ( stderr, "Number of output depth samples per trace = %d\n", nz );
fprintf ( stderr, "Number of traces = %d, number of samples per trace = %d\n", ntr, ns );
fprintf ( stderr, "Time sample rate (milliseconds) = %f\n", dt_msec );
fprintf ( stderr, "Vwater = %f (meters/second)\n", vwater );
fprintf ( stderr, "Location scalar = %d\n", scalar );
fprintf ( stderr, "\n" );
}
rewind (stdin);
if ( ns > nz ) {
depth = ealloc1double ( ns );
} else {
depth = ealloc1double ( nz );
}
tr_amp = ealloc1double ( ns );
factor1 = 0.0005;
delrt_depth = 0.0;
/* Main loop over traces */
for ( k = 0; k < ntr; ++k ) {
gettr (&tr);
x_loc = tr.sx / scalar;
y_loc = tr.sy / scalar;
for ( n=ns; n < nz; ++n ) depth[n] = 0;
if ( x_loc >= grd_wb_twt.x_min && x_loc <= grd_wb_twt.x_max && y_loc >= grd_wb_twt.y_min && y_loc <= grd_wb_twt.y_max ) {
value_coeff_top_k = GMT_get_bcr_z (&grd_top_k, x_loc, y_loc, f_top_k, &edgeinfo_top_k, &bcr_top_k);
value_coeff_bottom_k = GMT_get_bcr_z (&grd_bottom_k, x_loc, y_loc, f_bottom_k, &edgeinfo_bottom_k, &bcr_bottom_k);
value_coeff_wb_twt = GMT_get_bcr_z (&grd_wb_twt, x_loc, y_loc, f_wb_twt, &edgeinfo_wb_twt, &bcr_wb_twt);
value_coeff_top_twt = GMT_get_bcr_z (&grd_top_twt, x_loc, y_loc, f_top_twt, &edgeinfo_top_twt, &bcr_top_twt);
value_coeff_middle_twt = GMT_get_bcr_z (&grd_middle_twt, x_loc, y_loc, f_middle_twt, &edgeinfo_middle_twt, &bcr_middle_twt);
value_coeff_bottom_twt = GMT_get_bcr_z (&grd_bottom_twt, x_loc, y_loc, f_bottom_twt, &edgeinfo_bottom_twt, &bcr_bottom_twt);
value_coeff_middle_vint = GMT_get_bcr_z (&grd_middle_vint, x_loc, y_loc, f_middle_vint, &edgeinfo_middle_vint, &bcr_middle_vint);
value_coeff_bottom_vint = GMT_get_bcr_z (&grd_bottom_vint, x_loc, y_loc, f_bottom_vint, &edgeinfo_bottom_vint, &bcr_bottom_vint);
value_coeff_campan_vint = GMT_get_bcr_z (&grd_campan_vint, x_loc, y_loc, f_campan_vint, &edgeinfo_campan_vint, &bcr_campan_vint);
value_coeff_top_z = GMT_get_bcr_z (&grd_top_z, x_loc, y_loc, f_top_z, &edgeinfo_top_z, &bcr_top_z);
value_coeff_bottom_z = GMT_get_bcr_z (&grd_bottom_z, x_loc, y_loc, f_bottom_z, &edgeinfo_bottom_z, &bcr_bottom_z);
if ( GMT_is_dnan (value_coeff_wb_twt) || GMT_is_dnan (value_coeff_top_k) || GMT_is_dnan (value_coeff_top_twt) ||\
GMT_is_dnan (value_coeff_bottom_twt) || GMT_is_dnan (value_coeff_campan_vint) || GMT_is_dnan (value_coeff_bottom_k) ||\
GMT_is_dnan (value_coeff_top_z) || GMT_is_dnan (value_coeff_bottom_z) ) {
for ( n=0; n < nz; ++n ) tr.data[n] = 0;
tr.delrt = 0;
tr.trid = 0;
} else {
water_depth = value_coeff_wb_twt * factor1 * vwater;
ratio = vwater / value_coeff_top_k;
if ( verbose == 2 ) {
fprintf ( stderr, "\n" );
fprintf ( stderr, "Trace num = %5d X-Loc = %10.2f Y-Loc = %10.2f\n", k+1, x_loc, y_loc );
fprintf ( stderr, "Top_K = %8.5f\n", value_coeff_top_k );
fprintf ( stderr, "Bottom_K = %8.5f\n", value_coeff_bottom_k );
fprintf ( stderr, "WB_TWT = %8.2f\n", value_coeff_wb_twt );
fprintf ( stderr, "TOP_TWT = %8.2f\n", value_coeff_top_twt );
fprintf ( stderr, "MIDDLE_TWT = %8.2f\n", value_coeff_middle_twt );
fprintf ( stderr, "BOTTOM_TWT = %8.2f\n", value_coeff_bottom_twt );
fprintf ( stderr, "MIDDLE_VINT = %8.2f\n", value_coeff_middle_vint );
fprintf ( stderr, "BOTTOM_VINT = %8.2f\n", value_coeff_bottom_vint );
fprintf ( stderr, "CAMPANIAN_VINT = %8.2f\n", value_coeff_campan_vint );
fprintf ( stderr, "TOP_Z = %8.2f\n", value_coeff_top_z );
fprintf ( stderr, "BOTTOM_Z = %8.2f\n", value_coeff_bottom_z );
}
delta_twt = value_coeff_bottom_twt - value_coeff_top_twt;
delta_k = value_coeff_bottom_k - value_coeff_top_k;
gradient = delta_k / delta_twt;
for ( n=0; n < ns; ++n ) {
tr_amp[n] = tr.data[n];
if ( tr.delrt == 0 ) {
tr_msec = n * dt_msec;
} else {
tr_msec = tr.delrt + ( n * dt_msec );
}
if ( tr_msec <= value_coeff_wb_twt ) {
depth[n] = tr_msec * factor1 * vwater;
if ( tr_msec <= tr.delrt ) delrt_depth = depth[n];
} else if ( tr_msec <= value_coeff_top_twt ) {
tr_msec_orig = tr_msec;
tr_msec = ( tr_msec - value_coeff_wb_twt ) * factor1;
depth[n] = ( ratio * (exp (value_coeff_top_k*tr_msec) - 1.0) ) + water_depth;
if ( tr_msec_orig <= tr.delrt ) delrt_depth = depth[n];
} else if ( tr_msec > value_coeff_top_twt && tr_msec <= value_coeff_bottom_twt ) {
K = value_coeff_top_k + ( ( tr_msec - value_coeff_top_twt ) * gradient );
tr_msec_orig = tr_msec;
tr_msec = ( tr_msec - value_coeff_wb_twt ) * factor1;
ratio = vwater / K;
depth[n] = ( ratio * (exp (K*tr_msec) - 1.0) ) + water_depth;
if ( tr_msec_orig <= tr.delrt ) delrt_depth = depth[n];
/* fprintf ( stderr, "Trace = %5d, Sample = %5d, Top_TWT = %8.2f, TWT = %8.2f, Bottom_TWT = %8.2f, Top_Z = %8.2f, Depth = %8.2f, Bottom_Z = %8.2f, Delta_twt = %8.2f, Delta_K = %10.6f, Gradient = %10.6f, K = %10.6f\n",\
k, n, value_coeff_top_twt, n * dt_msec, value_coeff_bottom_twt, value_coeff_top_z, depth[n], value_coeff_bottom_z, delta_twt, delta_k, gradient, K ); */
} else if ( tr_msec > value_coeff_bottom_twt ) {
tr_msec_orig = tr_msec;
tr_msec = ( tr_msec - value_coeff_wb_twt ) * factor1;
ratio = vwater / value_coeff_bottom_k;
depth[n] = ( ratio * (exp (value_coeff_bottom_k*tr_msec) - 1.0) ) + water_depth;
if ( tr_msec_orig <= tr.delrt ) delrt_depth = depth[n];
}
}
for ( n=0; n < nz; ++n ) {
depth_input = n * dz;
if ( depth_input < delrt_depth ) {
tr.data[n] = 0.0;
} else {
dintlin ( ns, depth, tr_amp, tr_amp[0], tr_amp[ns-1], 1, &depth_input, &_output );
tr.data[n] = (float) amp_output;
}
}
tr.trid = 1;
}
tr.ns = nz;
tr.delrt = 0;
tr.dt = nint(dz*1000);
puttr (&tr);
} else {
fprintf ( stderr, "Input trace = %d, Xloc = %.0f Yloc = %.0f is out of bounds\n", k, x_loc, y_loc);
}
}
GMT_free ((void *)f_top_k);
GMT_free ((void *)f_bottom_k);
GMT_free ((void *)f_wb_twt);
GMT_free ((void *)f_top_twt);
GMT_free ((void *)f_middle_twt);
GMT_free ((void *)f_bottom_twt);
GMT_free ((void *)f_middle_vint);
GMT_free ((void *)f_bottom_vint);
GMT_free ((void *)f_campan_vint);
free1double (depth);
free1double (tr_amp);
GMT_end (argc, argv);
return (0);
}
int main (int argc, char **argv) {
char temp[256];
int kount, nx, ny, nt;
short verbose;
double x, y, t, dv;
double dx, dy, dt;
double xmin, xmax, ymin, ymax, tmin, tmax;
double x0, x1, y0, y1;
int iloc, jloc, kloc, one, zero;
int ***num;
double value;
double ***x_array, ***y_array, ***t_array, ***dv_array;
register int i, j, k;
initargs(argc, argv);
requestdoc (0);
if (!getparshort("verbose" , &verbose)) verbose = 0;
dx = dy = 25.0;
dt = 1.0;
x0 = 511797.36;
x1 = 527792.88;
y0 = 152443.84;
y1 = 169653.51;
kount = 0;
xmin = ymin = tmin = DBL_MAX;
xmax = ymax = tmax = DBL_MIN;
while (((char *) NULL) != fgets ( temp, sizeof(temp), stdin )) {
(void) sscanf ( ((&(temp[0]))), "%lf%lf%lf%lf", &x, &y, &t, &dv );
xmin = min ( xmin, x );
ymin = min ( ymin, y );
tmin = min ( tmin, t );
xmax = max ( xmax, x );
ymax = max ( ymax, y );
tmax = max ( tmax, t );
++kount;
}
nx = nint ( ( xmax - xmin ) / dx ) + 1;
ny = nint ( ( ymax - ymin ) / dy ) + 1;
nt = nint ( ( tmax - tmin ) / dt ) + 1;
if ( verbose ) {
fprintf ( stderr, "Number of input elements = %5d, xmin = %.2f, xmax = %.2f, ymin = %.2f, ymax = %.2f, tmin = %.2f, tmax = %.2f\n", kount+1, xmin, xmax, ymin, ymax, tmin, tmax );
fprintf ( stderr, "dx = %.2f, dy = %.2f, dt = %.2f, nx = %5d, ny = %5d, nt = %5d\n", dx, dy, dt, nx, ny, nt );
}
num = ealloc3int ( nt, ny, nx );
x_array = ealloc3double ( nt, ny, nx );
y_array = ealloc3double ( nt, ny, nx );
t_array = ealloc3double ( nt, ny, nx );
dv_array = ealloc3double ( nt, ny, nx );
for ( i = 0; i < nx; ++i ) for ( j = 0; j < ny; ++j ) for ( k = 0; k < nt; ++k ) num[i][j][k] = 0;
one = 1;
zero = 0;
rewind ( stdin );
while (((char *) NULL) != fgets ( temp, sizeof(temp), stdin )) {
(void) sscanf ( ((&(temp[0]))), "%lf%lf%lf%lf", &x, &y, &t, &dv );
iloc = min ( max ( nint ( ( x - xmin ) / dx ), 0 ), nx );
jloc = min ( max ( nint ( ( y - ymin ) / dx ), 0 ), ny );
kloc = min ( max ( nint ( ( t - tmin ) / dt ), 0 ), nt );
num[iloc][jloc][kloc] += one;
x_array[iloc][jloc][kloc] += x;
y_array[iloc][jloc][kloc] += y;
t_array[iloc][jloc][kloc] += t;
dv_array[iloc][jloc][kloc] += dv;
}
for ( i = 0; i < nx; ++i ) {
for ( j = 0; j < ny; ++j ) {
for ( k = 0; k < nt; ++k ) {
if ( num[i][j][k] > zero ) {
value = num[i][j][k];
x = x_array[i][j][k] / value;
y = y_array[i][j][k] / value;
t = t_array[i][j][k] / value;
dv = dv_array[i][j][k] / value;
printf ( "%-.2f %.2f %.2f %.4f\n", x, y, t, dv );
}
}
}
}
tmin = nint ( tmin );
tmax = nint ( tmax );
printf ( "%-.2f %.2f %.2f %.4f\n", x0, y0, tmin, 0.0);
printf ( "%-.2f %.2f %.2f %.4f\n", x0, y1, tmin, 0.0);
printf ( "%-.2f %.2f %.2f %.4f\n", x1, y0, tmin, 0.0);
printf ( "%-.2f %.2f %.2f %.4f\n", x1, y1, tmin, 0.0);
printf ( "%-.2f %.2f %.2f %.4f\n", x0, y0, tmax, 0.0);
printf ( "%-.2f %.2f %.2f %.4f\n", x0, y1, tmax, 0.0);
printf ( "%-.2f %.2f %.2f %.4f\n", x1, y0, tmax, 0.0);
printf ( "%-.2f %.2f %.2f %.4f\n", x1, y1, tmax, 0.0);
free3int ( num );
free3double ( x_array );
free3double ( y_array );
free3double ( t_array );
free3double ( dv_array );
return EXIT_SUCCESS;
}
int
main (int argc, char **argv)
{
short verbose; /* if 1(yes) echo parameters to stderr */
float tmin; /* minimum time to pass */
float tmax; /* maximum time to pass */
/* unsigned short ns_out;*/ /* number of time samples on output */
unsigned ns_out; /* number of time samples on output */
int utmin,utmax; /* tmin and tmax i usec */
int ut1_in; /* start time on input trace in usec */
int ut2_in; /* end time on input trace in usec */
int dt;
float fill;
/* initialize arguments */
initargs (argc, argv);
requestdoc (1);
/* get parameters from first trace */
if (!gettr (&tr)) err ("can't get first trace");
if( !getparint("dt" ,&dt ) ){
dt=tr.dt;
}
if( !getparfloat( "fill" ,&fill ) ){
fill=0.0;
}
if (getparfloat ("tmin", &tmin)) utmin = NINT(1e06 * tmin);
else utmin = 1e03 * tr.delrt;
if (getparfloat ("tmax", &tmax)) utmax = NINT(1e06 * tmax);
else utmax = utmin + tr.ns * dt;
if (!getparshort ("verbose", &verbose)) verbose = 0;
/* check utmin, delrt */
if (utmin >= utmax) err ("utmin (%i) >= utmax (%i) ?!", utmin, utmax);
if ( NINT(1e-03 * utmin) > 32767 || NINT(1e-03 * utmin) < -32768)
err (" delrt exceeds short");
/* set output number of samples */
ns_out = (utmax - utmin) / dt;
if (verbose) warn ("IN %u samples OUT %u samples", tr.ns, ns_out);
/* sushift.c:105: warning: comparison is always false due to limited range of data type */
if (ns_out > SU_NFLTS)
err ("ns_out=%u exceeds SU_NFLTS=%u", ns_out, SU_NFLTS);
/* Main loop over traces */
do {
/* actual start/end time of input trace */
ut1_in = 1000 * tr.delrt;
ut2_in = ut1_in + dt * tr.ns;
if (ut1_in != utmin || ut2_in != utmax) {
int i;
int it,it1,it2; /* ..sample index */
int ut1,ut2,ut; /* times in usec */
float *temp;
ut = ut1 = ut2 = 0;
/*
* trace fully/partially inside/outside of the time
* window ?
*/
if (ut1_in < utmin && ut2_in <= utmax) {
ut1 = utmin - ut1_in;
ut = ut2_in - utmin;
} else if (ut1_in < utmin && ut2_in > utmax) {
ut1 = utmin - ut1_in;
ut = utmax - utmin;
} else if (ut1_in >= utmin && ut2_in <= utmax) {
ut2 = ut1_in - utmin;
ut = ut2_in - ut1_in;
} else if (ut1_in >= utmin && ut2_in > utmax) {
ut2 = ut1_in - utmin;
ut = utmax - ut1_in;
} else {
err (" internal error : ut1=%i ut2=%i ut=%i ut1_in=%i ut2_in=%i",
ut1, ut2, ut, ut1_in, ut2_in);
}
it1 = ut1 / dt;
it2 = ut2 / dt;
it = ut / dt;
temp = ealloc1float ( ns_out);
/* make a filled temp trace */
for (i = 0; i < ns_out; i++)
temp[i] = fill;
/*
* copy only the data inside of the time window to
* the temp trace
*/
for (i = 0; i < it; i++)
temp[it2 + i] = tr.data[it1 + i];
/* copy the full temp trace to the tr struct */
for (i = 0; i < ns_out; i++)
tr.data[i] = temp[i];
free (temp);
}
tr.delrt = (short) (1e-03 * utmin);
tr.ns = ns_out;
puttr (&tr);
} while (gettr (&tr));
return(CWP_Exit());
}
