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) { /********************* variables declaration **************************/ int info, itype, lda, ldb, lwork, order; /* variables for lapack function */ char jobz, uplo; /* variables for lapack function */ int nfreq; /* number of frequencies displayed on the screen */ int d; /* dimension of the problem - determine the size r of the partial basis*/ int shape; /* shape of the body */ int r; /* actual size of the partial basis */ int i, j; /* indices */ int ir1; int *itab, *ltab, *mtab, *ntab; /* tabulation of indices */ int *irk; int k; int ns; /* symmetry of the system */ int hextype; /* type of hexagonal symmetry - VTI or HTI*/ double d1, d2, d3; /* dimension of the sample */ double rho; /* density */ double **cm; double ****c; /* stiffness tensor */ double **e, **gamma, *work, **w; /* matrices of the eigenvalue problem */ double *wsort; int outeigen; /* 1 if eigenvectors calculated */ char *eigenfile; /** FILE *file; */ /********************* end variables declaration **********************/ /* hook up getpar to handle the parameters */ initargs(argc,argv); requestdoc(1); /* get required parameters */ if (!getparint("d", &d)) err("must specify d!\n"); if (!getpardouble("d1", &d1)) err("must specify d1!\n"); if (!getpardouble("d2", &d2)) err("must specify d2!\n"); if (!getpardouble("d3", &d3)) err("must specify d3!\n"); if (!getpardouble("rho", &rho)) err("must specify rho!\n"); if (!getparint("ns", &ns)) err("must specify ns!\n"); cm=ealloc2double(6,6); for (i=0; i<6; ++i) for (j=0; j<6; ++j) cm[i][j]=0.0; if (ns==2) { /* isotropic */ if (!getpardouble("c11", &cm[0][0])) err("must specify c11!\n"); if (!getpardouble("c44", &cm[3][3])) err("must specify c44!\n"); cm[0][0]=cm[0][0]/100; cm[3][3]=cm[3][3]/100; cm[1][1]=cm[2][2]=cm[0][0]; cm[4][4]=cm[5][5]=cm[3][3]; cm[0][1]=cm[0][2]=cm[1][2]=cm[0][0]- 2.0*cm[3][3]; cm[1][0]=cm[2][0]=cm[2][1]=cm[0][0]- 2.0*cm[3][3]; } else if (ns==3) { /* cubic */ if (!getpardouble("c11", &cm[0][0])) err("must specify c11!\n"); if (!getpardouble("c12", &cm[0][1])) err("must specify c12!\n"); if (!getpardouble("c44", &cm[3][3])) err("must specify c44!\n"); cm[0][0]=cm[0][0]/100; cm[0][1]=cm[0][1]/100; cm[3][3]=cm[3][3]/100; cm[1][1]=cm[2][2]=cm[0][0]; cm[4][4]=cm[5][5]=cm[3][3]; cm[0][2]=cm[1][2]=cm[0][1]; cm[2][0]=cm[2][1]=cm[1][0]=cm[0][1]; } else if (ns==5) { /* hexagonal */ if (!getparint("hextype", &hextype)) err("must specify hextype!\n"); if (hextype==1) { /* VTI */ if (!getpardouble("c33", &cm[2][2])) err("must specify c33!\n"); if (!getpardouble("c23", &cm[1][2])) err("must specify c23!\n"); if (!getpardouble("c12", &cm[0][1])) err("must specify c12!\n"); if (!getpardouble("c44", &cm[3][3])) err("must specify c44!\n"); if (!getpardouble("c66", &cm[5][5])) err("must specify c66!\n"); cm[2][2]=cm[2][2]/100; cm[1][2]=cm[1][2]/100; cm[0][1]=cm[0][1]/100; cm[3][3]=cm[3][3]/100; cm[5][5]=cm[5][5]/100; cm[0][0]=cm[1][1]=2.0*cm[5][5] + cm[0][1]; cm[0][2]=cm[2][0]=cm[2][1]=cm[1][2]; cm[1][0]=cm[0][1]; cm[4][4]=cm[3][3]; } else if (hextype==2) { /* HTI */ if (!getpardouble("c11", &cm[0][0])) err("must specify c11!\n"); if (!getpardouble("c33", &cm[2][2])) err("must specify c33!\n"); if (!getpardouble("c12", &cm[0][1])) err("must specify c12!\n"); if (!getpardouble("c44", &cm[3][3])) err("must specify c44!\n"); if (!getpardouble("c66", &cm[5][5])) err("must specify c66!\n"); cm[0][0]=cm[0][0]/100; cm[2][2]=cm[2][2]/100; cm[0][1]=cm[0][1]/100; cm[3][3]=cm[3][3]/100; cm[5][5]=cm[5][5]/100; cm[1][2]=cm[2][1]=cm[2][2] - 2.0*cm[3][3]; cm[0][2]=cm[1][0]=cm[2][0]=cm[0][1]; cm[1][1]=cm[2][2]; cm[4][4]=cm[5][5]; } else { err("for hexagonal symmetry hextype must equal 1 (VTI) or 2 (HTI)!\n"); } } else if (ns==6){ /* tetragonal */ if (!getpardouble("c11", &cm[0][0])) err("must specify c11!\n"); if (!getpardouble("c33", &cm[2][2])) err("must specify c33!\n"); if (!getpardouble("c23", &cm[1][2])) err("must specify c23!\n"); if (!getpardouble("c12", &cm[0][1])) err("must specify c12!\n"); if (!getpardouble("c44", &cm[3][3])) err("must specify c44!\n"); if (!getpardouble("c66", &cm[5][5])) err("must specify c66!\n"); cm[0][0]=cm[0][0]/100; cm[2][2]=cm[2][2]/100; cm[1][2]=cm[1][2]/100; cm[3][3]=cm[3][3]/100; cm[0][1]=cm[0][1]/100; cm[5][5]=cm[5][5]/100; cm[1][1]=cm[0][0]; cm[0][2]=cm[2][0]=cm[1][2]; cm[1][0]=cm[0][1]; cm[2][1]=cm[1][2]; cm[4][4]=cm[3][3]; } else if (ns==9){/* orthorhombic */ if (!getpardouble("c11", &cm[0][0])) err("must specify c11!\n"); if (!getpardouble("c22", &cm[1][1])) err("must specify c22!\n"); if (!getpardouble("c33", &cm[2][2])) err("must specify c33!\n"); if (!getpardouble("c23", &cm[1][2])) err("must specify c23!\n"); if (!getpardouble("c13", &cm[0][2])) err("must specify c13!\n"); if (!getpardouble("c12", &cm[0][1])) err("must specify c12!\n"); if (!getpardouble("c44", &cm[3][3])) err("must specify c44!\n"); if (!getpardouble("c55", &cm[4][4])) err("must specify c55!\n"); if (!getpardouble("c66", &cm[5][5])) err("must specify c66!\n"); cm[0][0]=cm[0][0]/100; cm[1][1]=cm[1][1]/100; cm[2][2]=cm[2][2]/100; cm[1][2]=cm[1][2]/100; cm[0][2]=cm[0][2]/100; cm[0][1]=cm[0][1]/100; cm[3][3]=cm[3][3]/100; cm[4][4]=cm[4][4]/100; cm[5][5]=cm[5][5]/100; cm[2][0]=cm[0][2]; cm[1][0]=cm[0][1]; cm[2][1]=cm[1][2]; } else err("given elatic moduli does not fit given ns"); /* get optional parameters */ if (!getparint("outeigen", &outeigen)) outeigen=0; if (outeigen!=0) if (!getparstring("eigenfile", &eigenfile)) err("must specify eigenfile since outeigen>0!\n"); if (!getparint("shape", &shape)) shape=1; /* changed from zero default to 1 */ if (!getparint("nfreq", &nfreq)) nfreq=10; /* dimension of the problem */ r= 3*(d+1)*(d+2)*(d+3)/6; d1=d1/2.0; /* half sample dimensions are used in calculations */ d2=d2/2.0; d3=d3/2.0; /* alloc work space*/ itab=ealloc1int(r); ltab=ealloc1int(r); mtab=ealloc1int(r); ntab=ealloc1int(r); /* relationship between ir and l,m,n - filling tables */ irk=ealloc1int(8); index_relationship(itab, ltab, mtab, ntab, d, irk); /* alloc workspace to solve for eigenvalues and eigenfunctions */ e= (double **) malloc(8*sizeof(double *)); for (k=0; k<8; ++k) e[k] = ealloc1double(irk[k]*irk[k]); gamma= (double **) malloc(8*sizeof(double *)); for (k=0; k<8; ++k) gamma[k] = ealloc1double(irk[k]*irk[k]); /* filling matrix e */ for (k=0; k<8; ++k) e_fill(e[k], itab, ltab, mtab, ntab, r, d1, d2, d3, rho, shape, k, irk); /* stiffness tensor calculation*/ c= (double ****) malloc(sizeof(double ***)*3); for (i=0; i<3; ++i) c[i]=ealloc3double(3,3,3); stiffness (c, cm); /* filling matrix gamma */ for (k=0; k<8; ++k) gamma_fill(gamma[k], itab, ltab, mtab, ntab, r, d1, d2, d3, c, shape, k, irk); /* clean workspace */ free1int(itab); free1int(ltab); free1int(mtab); free1int(ntab); for (i=0; i<3; ++i) free3double(c[i]); free(c); fprintf(stderr,"done preparing matrices\n"); /*-------------------------------------------------------------*/ /*--------- solve the generalized eigenvalue problem ----------*/ /*-------------------------------------------------------------*/ w= (double **) malloc(sizeof(double *)*8); itype=1; if (outeigen==0) jobz='N'; else jobz='V'; uplo='U'; for (k=0; k<8; ++k){ w[k] =ealloc1double(irk[k]); lda=ldb=irk[k]; order=irk[k]; lwork=MAX(1, 3*order-1); work=ealloc1double(lwork); /* lapack routine */ dsygv_(&itype, &jobz, &uplo, &order, gamma[k], &lda, e[k], &ldb, w[k], work, &lwork, &info); free1double(work); } /*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/ wsort=ealloc1double(r); for (i=0, k=0; k<8; ++k) for (ir1=0;ir1<irk[k];++ir1,++i) wsort[i]=w[k][ir1]; /* sorting the eigenfrequencies */ dqksort(r,wsort); for (i=0, ir1=0; ir1<nfreq;++i) if ((wsort[i]>0) && ((sqrt(wsort[i])/(2.0*PI))>0.00001)){ ++ir1; /*fprintf(stderr," f%d = %f\n", ir1, 1000000*sqrt(wsort[i])/(2.0*PI));*/ fprintf(stderr," f%d = %f\n", ir1, 1000000*sqrt(wsort[i])/(2.0*PI)); } /* modify output of freq values here*/ /* for (k=0;k<8;++k){ for (ir2=0;ir2<irk[k]*irk[k];++ir2){ fprintf(stderr,"gamma[%d][%d]=%f\n",k,ir2,gamma[k][ir2]); fprintf(stderr,"e[%d][%d]=%f\n",k,ir2,e[k][ir2]); } }*/ /******************* write eigenvectors in files ***************/ /*if (outeigen==1){ z=ealloc2double(r,r); for (ir1=0; ir1<r; ++ir1) for (ir2=0; ir2<r; ++ir2) z[ir2][ir1]=gamma[ir1][ir2*r+ir1]; */ /* change the order of the array at the same time */ /* since we go from fortran array */ /* to C array */ /* clean workspace */ /* free1double(gamma); file = efopen(eigenfile, "w"); efwrite(&irf, sizeof(int), 1, file); efwrite(w, sizeof(double), r, file); efwrite(z[0], sizeof(double), r*r, file); efclose(file);*/ /* clean workspace */ /* free2double(z); */ /* }*/ /* clean workspace */ /* free1double(w); */ /* end of main */ return EXIT_SUCCESS; }
void deriv_n_gauss(double dt, int nt, double t0, float fpeak, int n, double *w, int sign, int verbose) /**************************************************************************** deriv_n_gauss: Compute n-th order derivative of a Gaussian in double precision. ***************************************************************************** Input: dt sampling interval nt length of waveform in samples t0 time shift for (pseudo-) causality fpeak maximum frequency n order of derivative sign multiplier for polarity of waveform verbose flag for diagnostic messages ***************************************************************************** Output: w array of size nt containing the waveform ***************************************************************************** Return: none ***************************************************************************** Notes: Copyright (c) 2007 by the Society of Exploration Geophysicists. For more information, go to http://software.seg.org/2007/0004 . You must read and accept usage terms at: http://software.seg.org/disclaimer.txt before use. ***************************************************************************** Author: Werner M. Heigl, Apache Corporation, E&P Technology, November 2006 *****************************************************************************/ { int i; /* loop variable */ double sigma; /* temporal variance of Gaussian */ double C; /* normalization constant */ double *h = NULL; /* Hermite polynomial */ double *h0 = NULL; /* temp array for H_{n-1} */ double *h1 = NULL; /* temp array for H_{n} */ double *t = NULL; /* time vector */ /* allocate & initialize memory */ t = alloc1double(nt); h = alloc1double(nt); h0 = alloc1double(nt); h1 = alloc1double(nt); memset((void *) t , 0, DSIZE * nt); memset((void *) h , 0, DSIZE * nt); memset((void *) h0, 0, DSIZE * nt); memset((void *) h1, 0, DSIZE * nt); if (verbose) fprintf(stderr,"memory allocated and initialized/n"); /* initialize time vector */ for (i = 0; i < nt; ++i) t[i] = i * dt - t0; if (verbose) fprintf(stderr,"t[] initialized/n"); /* compute Gaussian */ sigma = n / ( 4 * PI * PI * fpeak * fpeak ); if (verbose) fprintf(stderr,"sigma=%f",sigma); for (i = 0; i < nt; ++i) w[i] = exp( - t[i] * t[i] / (2 * sigma) ); if (verbose) fprintf(stderr,"Gaussian computed/n"); /* compute Hermite polynomial */ for (i = 0; i < nt; ++i) { h0[i] = 1.0; h1[i] = t[i] / sigma; } if (n==1) memcpy((void *) h, (const void *) h1, DSIZE * nt); if (n>1) hermite_n_polynomial(h, h0, h1, t, nt, n, sigma); if (verbose) fprintf(stderr,"Hermite polynomial H_%d computed/n",n); /* compute waveform */ for (i = 0; i < nt;++i) w[i] = h[i] * w[i]; if (verbose) fprintf(stderr,"waveform computed/n"); /* find normalization constant */ C = fabs(w[0]); for (i = 1; i < nt; ++i) if (fabs(w[i]) > C) C = fabs(w[i]); if (ISODD(n)) C = -C; /* to account for (-1)^n */ if (verbose) fprintf(stderr,"C=%f/n",C); /* and finally normalize */ for (i = 0; i < nt; ++i) w[i] = sign * w[i] / C; if (verbose) fprintf(stderr,"waveform normalized/n"); /* check amplitude a t=0 */ if (verbose) fprintf(stderr,"w[o]=%.12f",w[0]); /* free memory */ free1double(h); free1double(h0); free1double(h1); free1double(t); if (verbose) fprintf(stderr,"memory freed/n"); }