int main(int argc, char* argv[])
{
int ix, iy, nx, ny;
float dx, dy, zx, zy, x, y, *trace;
sf_file angle;
sf_init(argc,argv);
angle=sf_output("out");
sf_setformat(angle,"native_float");
if (!sf_getint("nx",&nx)) nx=451;
if (!sf_getint("ny",&ny)) ny=451;
if (!sf_getfloat("dx",&dx)) dx=0.1;
if (!sf_getfloat("dy",&dy)) dy=0.1;
if (!sf_getfloat("zx",&zx)) zx=0.;
if (!sf_getfloat("zy",&zy)) zy=0.;
zx = tanf(SF_PI*zx/180.);
zy = tanf(SF_PI*zy/180.);
sf_putint(angle,"n1",2*nx-1);
sf_putfloat(angle,"o1",-(nx-1)*dx);
sf_putfloat(angle,"d1",dx);
sf_putstring(angle,"label1","In-line Offset Slope");
sf_putstring(angle,"unit1","degrees");
sf_putint(angle,"n2",2*ny-1);
sf_putfloat(angle,"o2",-(ny-1)*dy);
sf_putfloat(angle,"d2",dy);
sf_putstring(angle,"label2","Cross-line Offset Slope");
sf_putstring(angle,"unit2","degrees");
trace = sf_floatalloc(2*nx-1);
for (iy=-ny+1; iy < ny; iy++) {
y = tanf(iy*dy*SF_PI/180.);
for (ix=-nx+1; ix < nx; ix++) {
x = tanf(ix*dx*SF_PI/180.);
x = x*x*(1.+zx*zx) + 2.*x*y*zx*zy + y*y*(1.+zy*zy);
x /= (1.+zx*zx+zy*zy);
if (x > 0.) {
trace[ix+nx-1] = atanf(sqrtf(x)) * 180./SF_PI;
} else {
trace[ix+nx-1] = -1.;
}
}
sf_floatwrite(trace,2*nx-1,angle);
}
exit(0);
}
void puthead4x(sf_file Fo, int n1, int n2, int n3, int n4, float d1, float d2, float d3, float d4, float o1, float o2, float o3, float o4)
/*< put head for (y,x,z,t) domain float-type 3D data sets>*/
{
/* Read/Write axes */
sf_putint(Fo,"n1",n1);
sf_putint(Fo,"n2",n2);
sf_putint(Fo,"n3",n3);
sf_putint(Fo,"n4",n4);
sf_putfloat(Fo,"d1",d1);
sf_putfloat(Fo,"d2",d2);
sf_putfloat(Fo,"d3",d3);
sf_putfloat(Fo,"d4",d4);
sf_putfloat(Fo,"o1",o1);
sf_putfloat(Fo,"o2",o2);
sf_putfloat(Fo,"o3",o3);
sf_putfloat(Fo,"o4",o4);
sf_putstring(Fo,"label1","z");
sf_putstring(Fo,"label2","x");
sf_putstring(Fo,"label3","y");
sf_putstring(Fo,"label4","t");
sf_putstring(Fo,"unit1","km");
sf_putstring(Fo,"unit2","km");
sf_putstring(Fo,"unit3","km");
sf_putstring(Fo,"unit4","s");
}
int main(int argc, char* argv[])
{
float x; /* trace value */
int ns=512; /* number of samples */
int ntr=8; /* number of traces */
int dtime=16; /* one way time in samples through "ocean" layer */
float rbot=0.8; /* reflection strength of "ocean" bottom */
int h=100; /* location in samples of two way reverb train */
float amp=0.2; /* strength of reflector */
int loc=170; /* location of reflector on trace 1 in time samples */
int dip=12; /* dip of reflector in time samples */
int i, j, k, sgn;
float *trace;
sf_file traces;
sf_init(argc,argv);
traces = sf_output("out");
sf_setformat(traces,"native_float");
sf_putint(traces,"n1",ns);
sf_putint(traces,"n2",ntr);
sf_putfloat(traces,"o1",0);
sf_putfloat(traces,"d1",0.004);
sf_putfloat(traces,"o2",1);
sf_putfloat(traces,"d2",1);
sf_putstring(traces,"label1","Time");
sf_putstring(traces,"unit1","s");
sf_putstring(traces,"label2","Trace");
trace = sf_floatalloc(ns);
for (j = 0; j < ntr; j++) {
for (i = 0; i < ns; i++) {
if (i >= h && ((i-h) % dtime == 0)) {
k = (i-h)/dtime;
sgn = (ISODD(k) ? -1 : 1);
x = sgn * (k+1) * powf(rbot, k);
} else {
x = 0.0f;
}
if (i == loc + j*dip) x += amp;
trace[i] = x;
}
sf_floatwrite(trace,ns,traces);
}
exit(0);
}
void puthead2kx(sf_file Fo, int n1, int n2, float d1, float d2, float o1, float o2)
/*< put head for (kx,kz) domain float-type 2D data sets>*/
{
/* Read/Write axes */
sf_putint(Fo,"n1",n1);
sf_putint(Fo,"n2",n2);
sf_putfloat(Fo,"d1",d1);
sf_putfloat(Fo,"d2",d2);
sf_putfloat(Fo,"o1",o1);
sf_putfloat(Fo,"o2",o2);
sf_putstring(Fo,"label1","kz");
sf_putstring(Fo,"label2","kx");
sf_putstring(Fo,"unit1","2*pi/m");
sf_putstring(Fo,"unit2","2*pi/m");
}
void FwiParams::putOutputParams() {
sf_putint(vupdates, "n1", nz);
sf_putint(vupdates, "n2", nx);
sf_putfloat(vupdates, "d1", dz);
sf_putfloat(vupdates, "d2", dx);
sf_putstring(vupdates, "label1", "Depth");
sf_putstring(vupdates, "label2", "Distance");
sf_putstring(vupdates, "label3", "Iteration");
sf_putint(vupdates, "n3", niter);
sf_putint(vupdates, "d3", 1);
sf_putint(vupdates, "o3", 1);
sf_putint(grads, "n1", nz);
sf_putint(grads, "n2", nx);
sf_putint(grads, "n3", niter);
sf_putfloat(grads, "d1", dz);
sf_putfloat(grads, "d2", dx);
sf_putint(grads, "d3", 1);
sf_putint(grads, "o3", 1);
sf_putstring(grads, "label1", "Depth");
sf_putstring(grads, "label2", "Distance");
sf_putstring(grads, "label3", "Iteration");
sf_putint(illums, "n1", nz);
sf_putint(illums, "n2", nx);
sf_putfloat(illums, "d1", dz);
sf_putfloat(illums, "d2", dx);
sf_putint(illums, "n3", niter);
sf_putint(illums, "d3", 1);
sf_putint(illums, "o3", 1);
sf_putint(objs, "n1", niter);
sf_putint(objs, "n2", 1);
sf_putfloat(objs, "d1", 1);
sf_putfloat(objs, "o1", 1);
}
bool sf_fft_label(int axis /* axis number */,
const char* label /* input label */,
sf_file out /* output file */)
/*< Choose an output label appropriately.
Returns false if the label name is not recognized. >*/
{
char varname[8];
snprintf(varname,8,"label%d",axis);
if (0==strcmp(label,"Time")) {
sf_putstring(out,varname,"Frequency");
} else if (0==strcmp(label,"time")) {
sf_putstring(out,varname,"frequency");
} else if (0==strcmp(label,"Frequency")) {
sf_putstring(out,varname,"Time");
} else if (0==strcmp(label,"frequency")) {
sf_putstring(out,varname,"time");
} else {
return false;
}
return true;
}
void sf_setpars (sf_file file)
/*< change parameters to those from the command line >*/
{
char *in;
in = sf_histstring(file,"in");
sf_simtab_close(file->pars);
file->pars = sf_getpars();
if (NULL != in) {
sf_putstring(file,"in",in);
free(in);
}
}
void sf_fft_unit(int axis /* axis number */,
const char* unit /* input unit */,
sf_file out /* output file */)
/*< Change unit to 1/unit or vice versa >*/
{
size_t len;
char *unit2, varname[7];
snprintf(varname,7,"unit%d",axis);
if (NULL != unit) {
if (0==strcmp(unit,"s")) {
sf_putstring(out,varname,"Hz");
} else if (0==strcmp(unit,"Hz")) {
sf_putstring(out,varname,"s");
} else if (0==strncmp(unit,"1/",2)) {
sf_putstring(out,varname,unit+2);
} else {
len=strlen(unit)+3;
unit2 = sf_charalloc(len);
snprintf(unit2,len,"1/%s",unit);
sf_putstring(out,varname,unit2);
}
}
}
void puthead3kx(sf_file Fo, int n1, int n2, int n3, float d1, float d2, float d3, float o1, float o2, float o3)
/*< put head for (ky,kx,kz) domain float-type 3D data sets>*/
{
/* Read/Write axes */
sf_putint(Fo,"n1",n1);
sf_putint(Fo,"n2",n2);
sf_putint(Fo,"n3",n3);
sf_putfloat(Fo,"d1",d1);
sf_putfloat(Fo,"d2",d2);
sf_putfloat(Fo,"d3",d3);
sf_putfloat(Fo,"o1",o1);
sf_putfloat(Fo,"o2",o2);
sf_putfloat(Fo,"o3",o3);
sf_putstring(Fo,"label1","kz");
sf_putstring(Fo,"label2","kx");
sf_putstring(Fo,"label3","ky");
sf_putstring(Fo,"unit1","2*pi/m");
sf_putstring(Fo,"unit2","2*pi/m");
sf_putstring(Fo,"unit3","2*pi/m");
}
void puthead2dcommonshot(sf_file Fo, int n1, int n2, int n3, float d1, float d2, float d3, float o1, float o2, float o3)
/*< put head for 2D (x,t) domain common-shot data sets>*/
{
/* Read/Write axes */
sf_putint(Fo,"n1",n1);
sf_putint(Fo,"n2",n2);
sf_putint(Fo,"n3",n3);
sf_putfloat(Fo,"d1",d1);
sf_putfloat(Fo,"d2",d2);
sf_putfloat(Fo,"d3",d3);
sf_putfloat(Fo,"o1",o1);
sf_putfloat(Fo,"o2",o2);
sf_putfloat(Fo,"o3",o3);
sf_putstring(Fo,"label1","z");
sf_putstring(Fo,"label2","x");
sf_putstring(Fo,"label3","y");
sf_putstring(Fo,"unit1","km");
sf_putstring(Fo,"unit2","km");
sf_putstring(Fo,"unit3","km");
}
int main(int argc, char* argv[])
{
sf_file in=NULL, out=NULL;
int n1_traces;
int n1_headers;
char* header_format=NULL;
sf_datatype typehead;
/* kls do I need to add this? sf_datatype typein; */
float* fheader=NULL;
float* intrace=NULL;
int dim;
off_t n_in[SF_MAX_DIM];
int iaxis;
int dim_output;
int *indx_of_keys;
bool label_argparmread,n_argparmread,o_argparmread,d_argparmread;
char parameter[13];
char* label[SF_MAX_DIM];
off_t n_output[SF_MAX_DIM];
off_t n_outheaders[SF_MAX_DIM];
float o_output[SF_MAX_DIM];
float d_output[SF_MAX_DIM];
sf_axis output_axa_array[SF_MAX_DIM];
sf_file output=NULL, outheaders=NULL;
char* output_filename=NULL;
char* outheaders_filename=NULL;
sf_init (argc,argv);
/*****************************/
/* initialize verbose switch */
/*****************************/
/* verbose flag controls ammount of print */
/*( verbose=1 0 terse, 1 informative, 2 chatty, 3 debug ) */
/* fprintf(stderr,"read verbose switch. getint reads command line.\n"); */
if(!sf_getint("verbose",&verbose))verbose=1;
/* \n
flag to control amount of print
0 terse, 1 informative, 2 chatty, 3 debug
*/
fprintf(stderr,"verbose=%d\n",verbose);
/******************************************/
/* input and output data are stdin/stdout */
/******************************************/
if(verbose>0)fprintf(stderr,"read infile name\n");
in = sf_input ("in");
if(verbose>0)
fprintf(stderr,"read outfile name (probably default to stdout\n");
out = sf_output ("out");
if (!sf_histint(in,"n1_traces",&n1_traces))
sf_error("input data not define n1_traces");
if (!sf_histint(in,"n1_headers",&n1_headers))
sf_error("input data does not define n1_headers");
header_format=sf_histstring(in,"header_format");
if(strcmp (header_format,"native_int")==0) typehead=SF_INT;
else typehead=SF_FLOAT;
fprintf(stderr,"allocate headers. n1_headers=%d\n",n1_headers);
fheader = sf_floatalloc(n1_headers);
fprintf(stderr,"allocate intrace. n1_traces=%d\n",n1_traces);
intrace= sf_floatalloc(n1_traces);
/* maybe I should add some validation that n1== n1_traces+n1_headers+2
and the record length read in the second word is consistent with
n1. */
/* put the history from the input file to the output */
sf_fileflush(out,in);
/********************************************************************/
/* set up the output and outheaders files for the traces and headers */
/********************************************************************/
output_filename=sf_getstring("output");
/* \n
output trace filename. Required parameter with no default.
*/
if(NULL==output_filename) sf_error("output is a required parameter");
output=sf_output(output_filename);
outheaders_filename=sf_getstring("outheaders");
/* \n
Output trace header file name. Default is the input data
file name, with the final .rsf changed to _hdr.rsf.
*/
if(outheaders_filename==NULL){
/* compute headers_filename from output_filename by replacing the final
.rsf with _hdr.rsf */
if(!(0==strcmp(output_filename+strlen(output_filename)-4,".rsf"))){
fprintf(stderr,"parameter output, the name of the output file,\n");
fprintf(stderr,"does not end with .rsf, so header filename cannot\n");
fprintf(stderr,"be computed by replacing the final .rsf with\n");
fprintf(stderr,"_hdr.rsf.\n");
sf_error("default for outheaders parameter cannot be computed.");
}
outheaders_filename=malloc(strlen(output_filename)+60);
strcpy(outheaders_filename,output_filename);
strcpy(outheaders_filename+strlen(output_filename)-4,"_hdr.rsf\0");
if(verbose>1)
fprintf(stderr,"parameter outheader defaulted. Computed to be #%s#\n",
outheaders_filename);
}
if(verbose>1)fprintf(stderr,"parameter outheader input or computed #%s#\n",
outheaders_filename);
outheaders=sf_output(outheaders_filename);
/* get each of the axis information:
label2, n2, o2, d2,
label3, n3, o3, d3,
etc
label1, n1, o1, d1 is always defaulted from input */
sf_putint (output ,"n1" ,n1_traces );
sf_putint (outheaders,"n1" ,n1_headers);
sf_putfloat (outheaders,"d1" ,1 );
sf_putfloat (outheaders,"o1" ,0 );
sf_putstring(outheaders,"label1","none" );
sf_putstring(outheaders,"unit1" ,"none" );
dim_output=1;
for (iaxis=1; iaxis<SF_MAX_DIM; iaxis++){
label_argparmread=n_argparmread=o_argparmread=d_argparmread=false;
sprintf(parameter,"label%d",iaxis+1);
fprintf(stderr,"try to read %s\n",parameter);
if ((label[iaxis]=sf_getstring(parameter))) {
/*(label#=(2,...) name of each of the axes.
label1 is not changed from input. Each label must be a
header key like cdp, cdpt, or ep. The trace header
values are used to define the output trace location in
the output file. )*/
fprintf(stderr,"got %s=%s\n",parameter,label[iaxis]);
sf_putstring(output ,parameter,label[iaxis]);
sf_putstring(outheaders,parameter,label[iaxis]);
label_argparmread=true;
}
sprintf(parameter,"n%d",iaxis+1);
fprintf(stderr,"try to read %s\n",parameter);
if (sf_getlargeint (parameter,&n_output[iaxis])) {
/*( n#=(2,...) number of locations in the #-th dimension )*/
fprintf(stderr,"got %s=%lld\n",parameter,(long long) n_output[iaxis]);
sf_putint(output ,parameter,n_output[iaxis]);
sf_putint(outheaders,parameter,n_output[iaxis]);
n_argparmread=true;
}
sprintf(parameter,"o%d",iaxis+1);
if (sf_getfloat(parameter,&o_output[iaxis])) {
/*( o#=(2,...) origin of the #-th dimension )*/
sf_putfloat(output ,parameter,o_output[iaxis]);
sf_putfloat(outheaders,parameter,o_output[iaxis]);
o_argparmread=true;
}
sprintf(parameter,"d%d",iaxis+1);
if (sf_getfloat(parameter,&d_output[iaxis])) {
/*( d#=(2,...) delta in the #-th dimension )*/
sf_putfloat(output ,parameter,d_output[iaxis]);
sf_putfloat(outheaders,parameter,d_output[iaxis]);
d_argparmread=true;
}
if(!label_argparmread && !n_argparmread &&
! o_argparmread && !d_argparmread){
/* none of the parameter were read
you read all the parameters in the previous iteration
compute the output dimension and exit the loop */
dim_output=iaxis;
break;
}
if(label_argparmread && n_argparmread && o_argparmread && d_argparmread){
/* all the parameters for thisi axis were read. loop for next iaxis */
if(verbose>0){
fprintf(stderr,"label, n, i, and d read for iaxis%d\n",iaxis+1);
}
} else {
sf_warning("working on iaxis=%d. Program expects to read\n",iaxis+1);
sf_warning("label%d, n%d, i%d, and d%d from command line.\n",
iaxis+1,iaxis+1,iaxis+1,iaxis+1);
if(!label_argparmread) sf_error("unable to read label%d\n",iaxis+1);
if(!n_argparmread ) sf_error("unable to read n%d \n",iaxis+1);
if(!o_argparmread ) sf_error("unable to read o%d \n",iaxis+1);
if(!d_argparmread ) sf_error("unable to read d$d \n",iaxis+1);
}
}
/* if the input file is higher dimention than the output, then the
size of all the higher dimensions must be set to 1. */
/* kls use sf_axis to get structure for each axis with n, o, d, l, and u
this can be used to compute the index for sf_seek */
dim = sf_largefiledims(in,n_in);
for (iaxis=dim_output; iaxis<dim; iaxis++){
sprintf(parameter,"n%d",iaxis+1);
sf_putint(output,parameter,1);
sf_putint(outheaders,parameter,1);
}
/* for a test zero n_output and dim_output and see it you can read the
history file */
sf_largefiledims(output,n_output);
sf_largefiledims(outheaders,n_outheaders);
if(verbose>1){
for (iaxis=0; iaxis<SF_MAX_DIM; iaxis++){
fprintf(stderr,"from sf_largefiledims(output.. n%d=%lld outheaders=%lld\n",
iaxis+1,(long long) n_output[iaxis],(long long) n_outheaders[iaxis]);
}
}
/* the list header keys (including any extras) and get the index into
the header vector */
segy_init(n1_headers,in);
indx_of_keys=sf_intalloc(dim_output);
for (iaxis=1; iaxis<dim_output; iaxis++){
/* kls need to check each of these key names are in the segy header and
make error message for invalid keys. Of does segykey do this? NO, just
segmentation fault. */
if(verbose>0)fprintf(stderr,"get index of key for %s\n",label[iaxis]);
indx_of_keys[iaxis]=segykey(label[iaxis]);
}
sf_fileflush(output,in);
sf_putint(outheaders,"n1",n1_headers);
if(0==strcmp("native_int",sf_histstring(in,"header_format"))){
sf_settype(outheaders,SF_INT);
} else {
sf_settype(outheaders,SF_FLOAT);
}
sf_fileflush(outheaders,in);
fprintf(stderr,"start trace loop\n");
/* kls maybe this should be in function sf_tahwritemapped_init */
{
off_t file_offset;
off_t i_output[SF_MAX_DIM];
float temp_float=0.0;
for(iaxis=0; iaxis<SF_MAX_DIM; iaxis++){
i_output[iaxis]=n_output[iaxis]-1;
}
file_offset=sf_large_cart2line(dim_output,n_output,i_output)*sizeof(float);
sf_seek(output,file_offset,SEEK_SET);
sf_floatwrite(&temp_float,1,output);
i_output[0]=n_outheaders[0]-1;
file_offset=sf_large_cart2line(dim_output,n_outheaders,i_output)*
sizeof(float);
sf_seek(outheaders,file_offset,SEEK_SET);
sf_floatwrite(&temp_float,1,outheaders);
}
for (iaxis=0; iaxis<SF_MAX_DIM; iaxis++){
/* sf_axis temp; */
output_axa_array[iaxis]=sf_iaxa(output,iaxis+1);
if(verbose>2){
/* temp=output_axa_array[iaxis]; */
fprintf(stderr,"axis=%d sf_n(output_axa_array[iaxis])=%d\n",
iaxis+1,sf_n(output_axa_array[iaxis]));
}
/* kls why does this fail?
fprintf(stderr,"temp->n=%d\n",temp->n);
*/
}
/***************************/
/* start trace loop */
/***************************/
fprintf(stderr,"start trace loop\n");
while (0==get_tah(intrace, fheader, n1_traces, n1_headers, in)){
if(verbose>1){
for(iaxis=2; iaxis<dim_output; iaxis++){
fprintf(stderr,"label[%d]=%s",
iaxis,label[iaxis]);
if(typehead == SF_INT)fprintf(stderr,"%d",
((int*)fheader)[indx_of_keys[iaxis]]);
else fprintf(stderr,"%f",
fheader[indx_of_keys[iaxis]]);
}
fprintf(stderr,"\n");
}
tahwritemapped(verbose,intrace, fheader,
n1_traces, n1_headers,
output, outheaders,
typehead, output_axa_array,
indx_of_keys, dim_output,
n_output,n_outheaders);
/**********************************************/
/* write trace and headers to the output pipe */
/**********************************************/
put_tah(intrace, fheader, n1_traces, n1_headers, out);
}
exit(0);
}
int main (int argc, char* argv[]) {
int nz, nx, ny, ic, nc;
float dz, oz, dx, ox, dy, oy;
size_t i, n, sz;
float *buf = NULL, *buf2 = NULL;
#ifdef HAVE_SSE
unsigned char pad[64];
#endif
sf_file velz, velx = NULL, theta = NULL, phi = NULL, eta = NULL, out;
bool verb;
Ugrid z_grid, x_grid, y_grid;
BCtype_s zBC, xBC, yBC;
multi_UBspline_3d_s *velspline = NULL;
sf_init (argc, argv);
velz = sf_input ("in");
/* Vertical velocity */
out = sf_output ("out");
/* Spline coefficients */
/* Spatial dimensions */
if (!sf_histint (velz, "n1", &nz)) sf_error ("No n1= in input");
if (!sf_histint (velz, "n2", &nx)) sf_error ("No n2= in input");
if (!sf_histint (velz, "n3", &ny)) sf_error ("No n3= in input");
if (!sf_histfloat (velz, "d1", &dz)) sf_error ("No d1= in input");
if (!sf_histfloat (velz, "o1", &oz)) oz = 0.0;
if (!sf_histfloat (velz, "d2", &dx)) sf_error ("No d2= in input");
if (!sf_histfloat (velz, "o2", &ox)) ox = 0.0;
if (!sf_histfloat (velz, "d3", &dy)) sf_error ("No d3= in input");
if (!sf_histfloat (velz, "o3", &oy)) oy = 0.0;
if (!sf_getbool ("verb", &verb)) verb = false;
/* verbosity flag */
n = (size_t)nz*(size_t)nx*(size_t)ny;
buf = sf_floatalloc (n);
nc = 1;
if (sf_getstring ("vx")) {
/* Horizontal velocity */
velx = sf_input ("vx");
nc++;
}
if (sf_getstring ("eta")) {
/* Anellipticity */
if (NULL == velx)
sf_error ("Need vx=, if eta= is given");
eta = sf_input ("eta");
nc++;
} else if (velx)
sf_error ("Need eta=, if vx= is given");
if (sf_getstring ("theta")) {
/* Tilt angle elevation */
if (NULL == velx)
sf_error ("Need vx=, if theta= is given");
theta = sf_input ("theta");
nc++;
}
if (sf_getstring ("phi")) {
/* Tilt angle azimuth */
if (NULL == theta)
sf_error ("Need theta=, if phi= is given");
phi = sf_input ("phi");
nc++;
}
z_grid.start = oz; z_grid.end = oz + (nz - 1)*dz; z_grid.num = nz;
x_grid.start = ox; x_grid.end = ox + (nx - 1)*dx; x_grid.num = nx;
y_grid.start = oy; y_grid.end = oy + (ny - 1)*dy; y_grid.num = ny;
zBC.lCode = zBC.rCode = NATURAL;
xBC.lCode = xBC.rCode = NATURAL;
yBC.lCode = yBC.rCode = NATURAL;
velspline = create_multi_UBspline_3d_s (y_grid, x_grid, z_grid, yBC, xBC, zBC, nc);
/* Read data and compute spline coefficients */
if (verb)
sf_warning ("Processing V_z");
sf_floatread (buf, n, velz);
if (1 == nc) {
/* Isotropic case - convert velocity to slowness */
if (verb)
sf_warning ("Converting to slowness for isotropic case");
for (i = 0; i < n; i++)
buf[i] = 1.0/buf[i];
} else {
/* Convert to V_z^2 */
for (i = 0; i < n; i++)
buf[i] *= buf[i];
}
ic = 0;
set_multi_UBspline_3d_s (velspline, ic, buf);
ic++;
if (velx) {
if (verb)
sf_warning ("Processing V_x");
buf2 = sf_floatalloc (n);
sf_floatread (buf2, n, velx);
sf_fileclose (velx);
/* Convert to V_x^2 */
for (i = 0; i < n; i++)
buf2[i] *= buf2[i];
set_multi_UBspline_3d_s (velspline, ic, buf2);
ic++;
/* Convert to (V_z*V_x)^2 */
for (i = 0; i < n; i++)
buf[i] *= buf2[i];
}
if (eta) {
if (verb)
sf_warning ("Processing Eta");
sf_floatread (buf2, n, eta);
sf_fileclose (eta);
/* Convert to -8*eta/(1 + 2*eta)*(V_z*V_x)^2 */
for (i = 0; i < n; i++) {
buf2[i] = -8.0*buf2[i]/(1.0 + 2.0*buf2[i]);
buf2[i] *= buf[i];
}
set_multi_UBspline_3d_s (velspline, ic, buf2);
ic++;
}
if (theta) {
if (verb)
sf_warning ("Processing Theta");
sf_floatread (buf, n, theta);
sf_fileclose (theta);
/* Convert to radians */
for (i = 0; i < n; i++)
buf[i] = buf[i]*SF_PI/180.0;
set_multi_UBspline_3d_s (velspline, ic, buf);
ic++;
}
if (phi) {
if (verb)
sf_warning ("Processing Phi");
sf_floatread (buf, n, phi);
sf_fileclose (phi);
/* Convert to radians */
for (i = 0; i < n; i++)
buf[i] = buf[i]*SF_PI/180.0;
set_multi_UBspline_3d_s (velspline, ic, buf);
ic++;
}
if (buf2)
free (buf2);
free (buf);
sz = (size_t)sizeof(multi_UBspline_3d_s) +
(size_t)velspline->nc;
#ifdef HAVE_SSE
if (sizeof(multi_UBspline_3d_s) % 64)
sz += 64 - (sizeof(multi_UBspline_3d_s) % 64);
#endif
/* Make output a 1-D file of coefficients */
sf_unshiftdim2 (velz, out, 1);
/* Set up output */
sf_settype (out, SF_UCHAR);
sf_putlargeint (out, "n1", sz);
sf_putfloat (out, "o1", 0.0);
sf_putfloat (out, "d1", 1.0);
sf_putstring (out, "label1", "Spline coefficients");
sf_putstring (out, "unit1", "");
sf_putstring (out, "label2", "");
sf_putstring (out, "unit2", "");
sf_putint (out, "Nz", nz);
sf_putfloat (out, "Oz", oz);
sf_putfloat (out, "Dz", dz);
sf_putint (out, "Nx", nx);
sf_putfloat (out, "Ox", ox);
sf_putfloat (out, "Dx", dx);
sf_putint (out, "Ny", ny);
sf_putfloat (out, "Oy", oy);
sf_putfloat (out, "Dy", dy);
sf_putint (out, "Nc", nc);
sf_putstring (out, "splines", "y");
if (verb) {
sf_warning ("Number of spline coefficients: %lu",
velspline->nc/(size_t)sizeof(float));
sf_warning ("Writing spline coefficients");
}
sf_ucharwrite ((unsigned char*)velspline, (size_t)sizeof(multi_UBspline_3d_s), out);
#ifdef HAVE_SSE
if (sizeof(multi_UBspline_3d_s) % 64)
sf_ucharwrite (pad, (size_t)(64 - (sizeof(multi_UBspline_3d_s) % 64)), out);
#endif
sf_ucharwrite ((unsigned char*)velspline->coefs, (size_t)velspline->nc, out);
destroy_Bspline (velspline);
return 0;
}
int main (int argc, char *argv[])
{
int n123, niter, order, nj1,nj2, i, j, liter, dim;
int n[SF_MAX_DIM], rect[3], nr, ir;
float p0, *u, *p, pmin, pmax, eps;
float **allu, **allp, d1, d2, d3, o1, o2, o3, *sendbuf, *recvbuf;
bool verb, **mm;
sf_file in, out, mask, dip0;
int cpuid, numprocs, nrpad, iturn;
MPI_Comm comm=MPI_COMM_WORLD;
sf_init(argc,argv);
MPI_Init(&argc, &argv);
MPI_Comm_rank(comm, &cpuid);
MPI_Comm_size(comm, &numprocs);
in = sf_input ("--input");
out = sf_output ("--output");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float type");
if (cpuid==0) sf_warning("numprocs=%d", numprocs);
dim = sf_filedims(in,n);
if (dim < 2) n[1]=1;
n123 = n[0]*n[1];
nr = 1;
for (j=2; j < dim; j++) {
nr *= n[j];
}
n[2]= 1;
rect[2]=1;
nj2=1;
if(nr%numprocs==0)
nrpad=nr;
else
nrpad=(nr/numprocs+1)*numprocs;
/* set up output dimension */
if(cpuid==0){
if (!sf_histfloat(in, "d1", &d1)) sf_error("No d1= in input");
if (!sf_histfloat(in, "o1", &o1)) sf_error("No o1= in input");
if (!sf_histfloat(in, "d2", &d2)) sf_error("No d2= in input");
if (!sf_histfloat(in, "o2", &o2)) sf_error("No o2= in input");
if (!sf_histfloat(in, "d3", &d3)) sf_error("No d3= in input");
if (!sf_histfloat(in, "o3", &o3)) sf_error("No o3= in input");
sf_putint(out, "n1", n[0]);
sf_putfloat(out, "d1", d1);
sf_putfloat(out, "o1", o1);
sf_putstring(out, "label1", "Depth");
sf_putstring(out, "unit1", "m");
sf_putint(out, "n2", n[1]);
sf_putfloat(out, "d2", d2);
sf_putfloat(out, "o2", o2);
sf_putstring(out, "label2", "Offset");
sf_putstring(out, "unit2", "m");
sf_putint(out, "n3", nr);
sf_putfloat(out, "d3", d3);
sf_putfloat(out, "o3", o3);
sf_putstring(out, "label3", "CIGs");
sf_putstring(out, "unit3", "m");
}
if (!sf_getint("niter",&niter)) niter=5;
/* number of iterations */
if (!sf_getint("liter",&liter)) liter=20;
/* number of linear iterations */
if (!sf_getint("rect1",&rect[0])) rect[0]=1;
/* dip smoothness on 1st axis */
if (!sf_getint("rect2",&rect[1])) rect[1]=1;
/* dip smoothness on 2nd axis */
if (!sf_getfloat("p0",&p0)) p0=0.;
/* initial dip */
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
if (!sf_getint("nj1",&nj1)) nj1=1;
/* antialiasing */
if (!sf_getbool("verb",&verb)) verb = false;
/* verbosity flag */
if (!sf_getfloat("pmin",&pmin)) pmin = -FLT_MAX;
/* minimum dip */
if (!sf_getfloat("pmax",&pmax)) pmax = +FLT_MAX;
/* maximum dip */
if (!sf_getfloat("eps",&eps)) eps=0.0f;
/* regularization */
/* initialize dip estimation */
dip3_init(n[0], n[1], n[2], rect, liter, eps, false);
/* initial dip file */
if(NULL != sf_getstring("dip0")){
dip0=sf_input("dip0");
}else{
dip0=NULL;
}
if(cpuid==0){
allu=sf_floatalloc2(n123, nrpad);
sf_floatread(allu[0], n123*nr, in);
for(ir=nr; ir<nrpad; ir++)
for(i=0; i<n123; i++)
allu[ir][i]=0.;
allp=sf_floatalloc2(n123, nrpad);
if(NULL != dip0){
sf_floatread(allp[0], n123*nr, dip0);
for(ir=nr; ir<nrpad; ir++)
for(i=0; i<n123; i++)
allp[ir][i]=0.;
}
}
u = sf_floatalloc(n123);
p = sf_floatalloc(n123);
/* masking operator */
if(NULL != sf_getstring("mask")) {
mm = sf_boolalloc2(n123,2);
mask = sf_input("mask");
if(cpuid==0) sf_floatread(u, n123, mask);
MPI_Bcast(u, n123, MPI_FLOAT, 0, comm);
mask32 (false, order, nj1, nj2, n[0], n[1], n[2], u, mm);
}else{
mm = (bool**) sf_alloc(2,sizeof(bool*));
mm[0] = mm[1] = NULL;
}
/* loop over third dimension */
for(iturn=0; iturn*numprocs<nrpad; iturn++){
ir=iturn*numprocs+cpuid;
if (cpuid==0 && verb) sf_warning("slice %d of %d;", ir+1, nr);
/* image data */
if(cpuid==0){
sendbuf=allu[iturn*numprocs];
recvbuf=u;
}else{
sendbuf=NULL;
recvbuf=u;
}
MPI_Scatter(sendbuf, n123, MPI_FLOAT, recvbuf, n123, MPI_FLOAT, 0, comm);
/* initialize t-x dip */
if(NULL != dip0) {
if(cpuid==0){
sendbuf=allp[iturn*numprocs];
recvbuf=p;
}else{
sendbuf=NULL;
recvbuf=p;
}
MPI_Scatter(sendbuf, n123, MPI_FLOAT, recvbuf, n123, MPI_FLOAT, 0, comm);
}else{
for(i=0; i < n123; i++) {
p[i] = p0;
}
}
/* estimate t-x dip */
if(ir<nr) dip3(false, 1, niter, order, nj1, u, p, mm[0], pmin, pmax);
if(cpuid==0){
sendbuf=p;
recvbuf=allp[iturn*numprocs];
}else{
sendbuf=p;
recvbuf=NULL;
}
MPI_Gather(sendbuf, n123, MPI_FLOAT, recvbuf, n123, MPI_FLOAT, 0, comm);
}
if(cpuid==0) sf_floatwrite(allp[0], n123*nr, out);
MPI_Finalize();
exit (0);
}
int main(int argc, char **argv)
{
int n1, n2, ninf, i1, i2, i, *inter2;
char *label, *unit;
float o1, d1, o2, d2, x, z;
float *v0, *dvdx, *dvdz, *x0, *z0, *trace, **inter;
sf_file model, surface;
sf_init(argc, argv);
surface = sf_input("in");
model = sf_output("out");
if (SF_FLOAT != sf_gettype(surface)) sf_error("Need float input");
if (!sf_histint(surface,"n1",&n2)) sf_error("No n1= in input");
if (!sf_histfloat(surface,"d1",&d2)) sf_error("No d1= in input");
if (!sf_histfloat(surface,"o1",&o2)) o2=0.;
sf_shiftdim(surface, model, 1);
sf_putint(model,"n3",1);
if (!sf_histint(surface,"n2",&ninf)) ninf=1;
if (!sf_getint("n1",&n1)) sf_error("Need n1=");
/* Number of samples on the depth axis */
if (!sf_getfloat("d1",&d1)) sf_error("Need d1=");
/* Sampling of the depth axis */
if (!sf_getfloat("o1",&o1)) o1=0.;
/* Origin of the depth axis */
sf_putint(model,"n1",n1);
sf_putfloat(model,"d1",d1);
sf_putfloat(model,"o1",o1);
if (NULL == (label = sf_getstring("label1"))) label="Depth";
/* depth axis label */
sf_putstring(model,"label1",label);
if (NULL != (unit = sf_getstring("unit1"))) /* depth axis unit */
sf_putstring(model,"unit1",unit);
inter = sf_floatalloc2(n2,ninf);
inter2 = sf_intalloc(ninf);
sf_floatread(inter[0],n2*ninf,surface);
ninf++; /* more layers than interfaces */
v0 = sf_floatalloc(ninf);
x0 = sf_floatalloc(ninf);
z0 = sf_floatalloc(ninf);
dvdx = sf_floatalloc(ninf);
dvdz = sf_floatalloc(ninf);
/* Input layer velocities and velocity derivatives */
if (!sf_getfloats("x0",x0,ninf))
for(i=0;i< ninf;i++) x0[i] = 0.;
if (!sf_getfloats("z0",z0,ninf))
for(i=0;i< ninf;i++) z0[i] = 0.;
if (!sf_getfloats("v00",v0,ninf))
for(i=0;i< ninf;i++) v0[i] = 1500.+ 500*i;
if (!sf_getfloats("dvdx",dvdx,ninf))
for(i=0;i< ninf;i++) dvdx[i] = 0.;
if (!sf_getfloats("dvdz",dvdz,ninf))
for(i=0;i< ninf;i++) dvdz[i] = 0.;
trace = sf_floatalloc(n1);
/* compute linear velocity */
for(i2=0; i2 < n2; i2++) {
x = o2+i2*d2;
for (i=0; i < ninf-1; i++) {
inter2[i] = floorf(0.5+(inter[i][i2]-o1)/d1);
}
for(i1=0; i1 < n1; i1++) {
z = o1+i1*d1;
for (i=0; i < ninf-1; i++) {
if (i1 < inter2[i]) break;
}
trace[i1] = v0[i] + (x-x0[i])*dvdx[i] + (z-z0[i])*dvdz[i];
}
sf_floatwrite(trace,n1,model);
}
exit(0);
}
int main(int argc, char* argv[])
{
int n[SF_MAX_DIM], a[SF_MAX_DIM], center[SF_MAX_DIM], gap[SF_MAX_DIM];
int *pch, *nh, dim, n123, nf, i, niter, nbf, nbp, id, ip, ig, np;
int *kk, *pp;
float *dd, eps, dabs, di;
nfilter aa, bb;
char varname[6], *lagfile;
sf_file in, flt, lag, mask, patch, reg;
sf_init(argc,argv);
in = sf_input("in");
flt = sf_output("out");
dim = sf_filedims(in,n);
if (NULL == (lagfile = sf_getstring("lag"))) sf_error("Need lag=");
/* output file for filter lags */
lag = sf_output(lagfile);
sf_settype(lag,SF_INT);
sf_putstring(flt,"lag",lagfile);
sf_putints(lag,"n",n,dim);
if (!sf_getints("a",a,dim)) sf_error("Need a=");
if (!sf_getints("center",center,dim)) {
for (i=0; i < dim; i++) {
center[i] = (i+1 < dim && a[i+1] > 1)? a[i]/2: 0;
}
}
if (!sf_getints("gap",gap,dim)) {
for (i=0; i < dim; i++) {
gap[i] = 0;
}
}
n123 = 1;
for (i=0; i < dim; i++) {
n123 *= n[i];
}
dd = sf_floatalloc(n123);
kk = sf_intalloc(n123);
if (NULL != sf_getstring("maskin")) {
/* optional input mask file */
mask = sf_input("maskin");
switch (sf_gettype(mask)) {
case SF_INT:
sf_intread (kk,n123,mask);
break;
case SF_FLOAT:
sf_floatread (dd,n123,mask);
for (i=0; i < n123; i++) {
kk[i] = (dd[i] != 0.);
}
break;
default:
sf_error ("Wrong data type in maskin");
break;
}
sf_fileclose (mask);
} else {
for (i=0; i < n123; i++) {
kk[i] = 1;
}
}
sf_floatread(dd,n123,in);
dabs = fabsf(dd[0]);
for (i=1; i < n123; i++) {
di = fabsf(dd[i]);
if (di > dabs) dabs=di;
}
random_init(2004);
for (i=0; i < n123; i++) {
dd[i] = dd[i]/dabs+ 100.*FLT_EPSILON*(random0()-0.5);;
}
pp = sf_intalloc(n123);
if (NULL != sf_getstring("pch")) {
patch = sf_input("pch");
if (SF_INT != sf_gettype(patch)) sf_error("Need int pch");
sf_intread(pp,n123,patch);
np = pp[0];
for (i=1; i < n123; i++) {
if (pp[i] > np) np = pp[i];
}
sf_fileclose(patch);
} else {
np = n123;
for (i=0; i < n123; i++) {
pp[i] = i;
}
}
aa = createnhelix(dim, n, center, gap, a, pp);
free (pp);
nf = aa->hlx[0]->nh;
nfind_mask(n123, kk, aa);
if(!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getfloat("epsilon",&eps)) eps=0.01;
/* regularization parameter */
sf_putint(flt,"n1",nf);
sf_putint(flt,"n2",np);
sf_putint(lag,"n1",nf);
sf_putint(lag,"n2",np);
for (i=2; i < dim; i++) {
sprintf(varname,"n%d",i+1);
sf_putint(flt,varname,1);
sf_putint(lag,varname,1);
}
for (ip=0; ip < np; ip++) {
sf_intwrite(aa->hlx[ip]->lag,nf,lag);
}
sf_fileclose(lag);
if (NULL != sf_getstring("maskout")) {
/* optional output mask file */
mask = sf_output("maskout");
for (i=0; i < n123; i++) {
kk[i] = aa->mis[i]? 0.: 1.;
}
sf_settype(mask,SF_INT);
sf_intwrite (kk,n123,mask);
}
reg = sf_input("filt");
if (!sf_histint(reg,"n1",&nbf)) sf_error("No n1= in filt");
if (!sf_histint(reg,"n2",&nbp)) sf_error("No n2= in filt");
if (NULL != sf_getstring("filt_pch")) {
patch = sf_input("filt_pch");
if (SF_INT != sf_gettype(patch)) sf_error("Need int filt_pch");
pp = sf_intalloc(np);
sf_intread(pp,np,patch);
} else {
if (nbp != np) sf_error ("Wrong filter size: %d != %d",nbp,np);
pp = NULL;
}
pch = sf_intalloc(nf*np);
nh = sf_intalloc(nbp);
for (i=0; i < nbp; i++) {
nh[i] = nbf;
}
for (id=ig=0; ig < nf; ig++) {
for (ip=0; ip < np; ip++, id++) {
pch[id] = (NULL != pp)? pp[ip]: ip;
}
}
bb = nallocate (nbp, nf*np, nh, pch);
if (NULL == (lagfile = sf_getstring("filt_lag")) &&
NULL == (lagfile = sf_histstring(reg,"lag")))
sf_error("Need filt_lag=");
/* input file for double-helix filter lags */
lag = sf_input(lagfile);
if (SF_INT != sf_gettype(lag)) sf_error("Need int filt_lag");
for (ip=0; ip < nbp; ip++) {
sf_intread (kk,nbf,lag);
for (i=0; i < nbf; i++) {
bb->hlx[ip]->lag[i] = kk[i]*nf;
}
}
for (ip=0; ip < nbp; ip++) {
sf_floatread (bb->hlx[ip]->flt,nbf,reg);
}
nfind_pef (n123, dd, aa, bb, niter, eps, nf);
for (ip=0; ip < np; ip++) {
sf_floatwrite (aa->hlx[ip]->flt,nf,flt);
}
exit(0);
}
int main (int argc, char* argv[]) {
int nz, nx, ny, nb, na, iz, ix, iy, ia, ib, fz, lz;
int icpu = 0, ncpu = 1, morder = 2, ic, nc = 1, mp = 1, ith = 0, inet = 0, tdel = 0;
float dz, oz, dx, ox, dy, oy, db, ob, da, oa, aper;
float z, x, y;
float ****e;
sf_file spdom, vspline = NULL, scgrid = NULL, scdaemon = NULL,
out;
char *ext = NULL;
bool verb, parab, mmaped, rfail;
sf_esc_slowness3 esc_slow;
sf_esc_scglstor3 esc_scgrid_lstor;
sf_esc_tracer3 *esc_tracers;
sf_esc_scgrid3 *esc_scgrids;
sf_timer timer;
sf_init (argc, argv);
if (!sf_stdin ()) {
spdom = NULL;
} else {
spdom = sf_input ("in");
/* Spatial (z,x,y) domain */
}
out = sf_output ("out");
/* Escape values */
/* Spatial dimensions */
if (spdom) {
if (!sf_histint (spdom, "n1", &nz)) sf_error ("No n1= in input");
if (!sf_histint (spdom, "n2", &nx)) sf_error ("No n2= in input");
if (!sf_histint (spdom, "n3", &ny)) sf_error ("No n3= in input");
if (!sf_histfloat (spdom, "d1", &dz)) sf_error ("No d1= in input");
if (!sf_histfloat (spdom, "o1", &oz)) sf_error ("No o1= in input");
if (!sf_histfloat (spdom, "d2", &dx)) sf_error ("No d2= in input");
if (!sf_histfloat (spdom, "o2", &ox)) sf_error ("No o2= in input");
if (!sf_histfloat (spdom, "d3", &dy)) sf_error ("No d3= in input");
if (!sf_histfloat (spdom, "o3", &oy)) sf_error ("No o3= in input");
if (!sf_histint (spdom, "icpu", &icpu)) icpu = 0;
/* Current CPU number */
if (!sf_histint (spdom, "ncpu", &ncpu)) ncpu = 1;
/* Total number of CPUs */
}
ext = sf_escst3_warnext (spdom);
if (!sf_getint ("nz", &nz) && !spdom) sf_error ("Need nz=");
/* Number of samples in z axis */
if (!sf_getfloat ("oz", &oz) && !spdom) sf_error ("Need oz=");
/* Beginning of z axis */
if (!sf_getfloat ("dz", &dz) && !spdom) sf_error ("Need dz=");
/* Sampling of z axis */
if (!sf_getint ("nx", &nx) && !spdom) sf_error ("Need nx=");
/* Number of samples in x axis */
if (!sf_getfloat ("ox", &ox) && !spdom) sf_error ("Need ox=");
/* Beginning of x axis */
if (!sf_getfloat ("dx", &dx) && !spdom) sf_error ("Need dx=");
/* Sampling of x axis */
if (!sf_getint ("ny", &ny) && !spdom) sf_error ("Need ny=");
/* Number of samples in y axis */
if (!sf_getfloat ("oy", &oy) && !spdom) sf_error ("Need oy=");
/* Beginning of y axis */
if (!sf_getfloat ("dy", &dy) && !spdom) sf_error ("Need dy=");
/* Sampling of y axis */
if (!sf_getint ("na", &na)) na = 360;
/* Number of azimuth phase angles */
da = 2.0*SF_PI/(float)na;
oa = 0.5*da;
if (!sf_getint ("nb", &nb)) nb = 180;
/* Number of inclination phase angles */
db = SF_PI/(float)nb;
ob = 0.5*db;
#ifdef _OPENMP
if (!sf_getint ("mp", &mp)) mp = 1;
/* Bufferization factor for multicore processing (number of points in buffer = mp*nc) */
if (!sf_getint ("nc", &nc)) nc = 0;
/* Number of threads to use for ray tracing (OMP_NUM_THREADS by default) */
if (nc)
omp_set_num_threads (nc); /* User override */
else
nc = omp_get_max_threads (); /* Current default */
sf_warning ("%s Using %d threads", ext, omp_get_max_threads ());
sf_warning ("%s Buffering %d points", ext, nc*mp);
#endif
if (!sf_getfloat ("aper", &aper)) aper = SF_HUGE;
/* Maximum aperture in x and y directions from current point (default - up to grid boundaries) */
if (aper != SF_HUGE)
aper = fabsf (aper);
if (!sf_getbool ("parab", ¶b)) parab = true;
/* y - use parabolic approximation of trajectories, n - straight line */
if (!sf_getbool ("mmaped", &mmaped)) mmaped = true;
/* n - do not use memory mapping for local data access */
if (!sf_getbool ("rfail", &rfail)) rfail = true;
/* n - do not quit if remote processing fails, try local processing */
if (!sf_getbool ("verb", &verb)) verb = false;
/* verbosity flag */
e = sf_floatalloc4 (ESC3_NUM, nb, na, nc*mp);
if (!sf_getstring ("vspl")) sf_error ("Need vspl=");
/* Spline coefficients for velocity model */
vspline = sf_input ("vspl");
if (!sf_getstring ("scgrid")) sf_error ("Need scgrid=");
/* Grid of supercells of local escape solutions */
scgrid = sf_input ("scgrid");
if (sf_getstring ("scdaemon")) {
/* Daemon for distributed computation */
scdaemon = sf_input ("scdaemon");
}
if (!sf_getint ("morder", &morder)) morder = 1;
/* Order of interpolation accuracy in the angular domain (1-3) */
#ifdef LINUX
if (!sf_getint ("inet", &inet)) inet = 1;
/* Network interface index */
#endif
if (!sf_getint ("tdel", &tdel)) tdel = 0;
/* Optional delay time before connecting (seconds) */
/* Slowness components module [(an)isotropic] */
esc_slow = sf_esc_slowness3_init (vspline, verb);
/* Make room for escape variables in output */
if (spdom)
sf_shiftdimn (spdom, out, 1, 3);
sf_putint (out, "n1", ESC3_NUM);
sf_putfloat (out, "o1", 0.0);
sf_putfloat (out, "d1", 1.0);
sf_putstring (out, "label1", "Escape variable");
sf_putstring (out, "unit1", "");
sf_putint (out, "n2", nb);
sf_putfloat (out, "d2", db*180.0/SF_PI);
sf_putfloat (out, "o2", ob*180.0/SF_PI);
sf_putstring (out, "label2", "Inclination");
sf_putstring (out, "unit2", "Degrees");
sf_putint (out, "n3", na);
sf_putfloat (out, "d3", da*180.0/SF_PI);
sf_putfloat (out, "o3", oa*180.0/SF_PI);
sf_putstring (out, "label3", "Azimuth");
sf_putstring (out, "unit3", "Degrees");
sf_putint (out, "n4", nz);
sf_putfloat (out, "o4", oz);
sf_putfloat (out, "d4", dz);
if (!spdom) {
sf_putstring (out, "label4", "Depth");
sf_putstring (out, "unit4", "");
}
sf_putint (out, "n5", nx);
sf_putfloat (out, "o5", ox);
sf_putfloat (out, "d5", dx);
if (!spdom) {
sf_putstring (out, "label5", "X");
sf_putstring (out, "unit5", "");
}
sf_putint (out, "n6", ny);
sf_putfloat (out, "o6", oy);
sf_putfloat (out, "d6", dy);
if (!spdom) {
sf_putstring (out, "label6", "Y");
sf_putstring (out, "unit6", "");
}
/* Save min/max possible escape values */
sf_putfloat (out, "Zmin", sf_esc_slowness3_oz (esc_slow));
sf_putfloat (out, "Zmax", sf_esc_slowness3_oz (esc_slow) +
(sf_esc_slowness3_nz (esc_slow) - 1)*
sf_esc_slowness3_dz (esc_slow));
sf_putfloat (out, "Xmin", sf_esc_slowness3_ox (esc_slow));
sf_putfloat (out, "Xmax", sf_esc_slowness3_ox (esc_slow) +
(sf_esc_slowness3_nx (esc_slow) - 1)*
sf_esc_slowness3_dx (esc_slow));
sf_putfloat (out, "Ymin", sf_esc_slowness3_oy (esc_slow));
sf_putfloat (out, "Ymax", sf_esc_slowness3_oy (esc_slow) +
(sf_esc_slowness3_ny (esc_slow) - 1)*
sf_esc_slowness3_dy (esc_slow));
esc_scgrid_lstor = sf_esc_scglstor3_init (scgrid, mmaped, ext, verb);
esc_tracers = (sf_esc_tracer3*)sf_alloc (nc, sizeof(sf_esc_tracer3));
esc_scgrids = (sf_esc_scgrid3*)sf_alloc (nc, sizeof(sf_esc_scgrid3));
sleep (tdel);
for (ic = 0; ic < nc; ic++) {
esc_tracers[ic] = sf_esc_tracer3_init (esc_slow);
sf_esc_tracer3_set_parab (esc_tracers[ic], parab);
esc_scgrids[ic] = sf_esc_scgrid3_init (scgrid, scdaemon, esc_tracers[ic], esc_scgrid_lstor,
morder, inet, (float)icpu/(float)ncpu, ext, rfail, verb && 0 == ic);
}
timer = sf_timer_init ();
for (iy = 0; iy < ny; iy++) {
y = oy + iy*dy;
/* Set aperture */
if (aper != SF_HUGE) {
for (ic = 0; ic < nc; ic++) {
sf_esc_scgrid3_set_ymin (esc_scgrids[ic], y - aper);
sf_esc_scgrid3_set_ymax (esc_scgrids[ic], y + aper);
}
}
for (ix = 0; ix < nx; ix++) {
x = ox + ix*dx;
/* Set aperture */
if (aper != SF_HUGE) {
for (ic = 0; ic < nc; ic++) {
sf_esc_scgrid3_set_xmin (esc_scgrids[ic], x - aper);
sf_esc_scgrid3_set_xmax (esc_scgrids[ic], x + aper);
}
}
if (verb)
sf_warning ("%s Projecting from lateral location %d of %d at y=%g, x=%g;",
ext, iy*nx + ix + 1, ny*nx, y, x);
/* Loop over chunks */
for (ic = 0; ic < (nz/(mp*nc) + ((nz % (nc*mp)) != 0)); ic++) {
fz = ic*nc*mp;
lz = (ic + 1)*nc*mp - 1;
if (lz >= nz)
lz = nz - 1;
sf_timer_start (timer);
#ifdef _OPENMP
#pragma omp parallel for \
schedule(dynamic,1) \
private(iz,ia,ib,ith,z) \
shared(fz,lz,iy,ix,nc,mp,nb,na,nz,nx,ny,ob,oa,oz,ox,oy,db,da,dz,dx,dy,x,y,esc_tracers,esc_scgrids,e,out)
#endif
for (iz = fz; iz <= lz; iz++) {
#ifdef _OPENMP
ith = omp_get_thread_num ();
#endif
z = oz + iz*dz;
if (sf_esc_tracer3_inside (esc_tracers[ith], &z, &x, &y, false)) {
sf_esc_scgrid3_compute (esc_scgrids[ith], z, x, y, oa, da, ob, db, na, nb, e[iz - fz][0][0]);
} else {
for (ia = 0; ia < na; ia++) {
for (ib = 0; ib < nb; ib++) {
e[iz - fz][ia][ib][ESC3_Z] = z;
e[iz - fz][ia][ib][ESC3_X] = x;
e[iz - fz][ia][ib][ESC3_Y] = y;
e[iz - fz][ia][ib][ESC3_T] = 0.0;
#ifdef ESC_EQ_WITH_L
e[iz - fz][ia][ib][ESC3_L] = 0.0;
#endif
}
}
}
} /* Loop over z */
sf_timer_stop (timer);
sf_floatwrite (e[0][0][0], (size_t)(lz - fz + 1)*(size_t)nb*(size_t)na*(size_t)ESC3_NUM,
out);
} /* Loop over z chunks */
} /* Loop over x */
} /* Loop over y */
if (verb) {
sf_warning (".");
sf_warning ("%s Total kernel time: %g s, per depth point: %g s",
ext, sf_timer_get_total_time (timer)/1000.0,
(sf_timer_get_total_time (timer)/(float)((size_t)nx*(size_t)ny*(size_t)nz))/1000.0);
}
sf_timer_close (timer);
for (ic = 0; ic < nc; ic++) {
sf_esc_tracer3_close (esc_tracers[ic]);
sf_esc_scgrid3_close (esc_scgrids[ic], verb);
}
free (esc_tracers);
free (esc_scgrids);
sf_esc_scglstor3_close (esc_scgrid_lstor);
sf_esc_slowness3_close (esc_slow);
free (e[0][0][0]);
free (e[0][0]);
free (e[0]);
free (e);
free (ext);
if (scdaemon)
sf_fileclose (scdaemon);
sf_fileclose (scgrid);
sf_fileclose (vspline);
return 0;
}
int main(int argc, char* argv[])
{
bool verb,pas,adj,abc; /* execution flags */
int ix, iz, it; /* index variables */
int nt, nx, nz, depth, nzxpad, nb, n2, snap;
float ox, oz, dx, dz, dt, dt2, idz2, idx2, cb;
int nxpad, nzpad;
float **vvpad;
float **dd, **mm, **vv, ***ww;
float **u0, **u1, **u2, **tmp; /* temporary arrays */
sf_file in, out, vel, wave; /* I/O files */
/* initialize Madagascar */
sf_init(argc,argv);
/* initialize OpenMP support */
#ifdef _OPENMP
omp_init();
#endif
if(!sf_getbool("verb", &verb)) verb=false;
/* verbosity flag */
if(!sf_getbool("adj", &adj)) adj=false;
/* adjoint flag, 0: modeling, 1: migration */
if(!sf_getbool("pas", &pas)) pas=false;
/* passive flag, 0: exploding reflector rtm, 1: passive seismic imaging */
if(!sf_getbool("abc",&abc)) abc = false;
/* absorbing boundary condition */
if(!sf_getint("snap", &snap)) snap=0;
/* wavefield snapshot flag */
if(!sf_getint("depth", &depth)) depth=0;
/* surface */
/* setup I/O files */
in = sf_input("in");
out = sf_output("out");
vel = sf_input("velocity");
/* velocity model */
/* Dimensions */
if(!sf_histint (vel, "n1", &nz)) sf_error("No n1= in velocity");
if(!sf_histint (vel, "n2", &nx)) sf_error("No n2= in velocity");
if(!sf_histfloat(vel, "o1", &oz)) sf_error("No o1= in velocity");
if(!sf_histfloat(vel, "o2", &ox)) sf_error("No o2= in velocity");
if(!sf_histfloat(vel, "d1", &dz)) sf_error("No d1= in velocity");
if(!sf_histfloat(vel, "d2", &dx)) sf_error("No d2= in velocity");
if(adj){ /* migration */
if(!sf_histint(in, "n1", &nt)) sf_error("No n1= in data");
if(!sf_histfloat(in, "d1", &dt)) sf_error("No d1= in data");
if(!sf_histint(in, "n2", &n2) || n2!=nx) sf_error("Need n2=%d in data", nx);
sf_putint (out, "n1", nz);
sf_putfloat (out, "o1", oz);
sf_putfloat (out, "d1", dz);
sf_putstring(out, "label1", "Depth");
sf_putstring(out, "unit1" , "km");
sf_putint (out, "n2", nx);
sf_putfloat (out, "o2", ox);
sf_putfloat (out, "d2", dx);
sf_putstring(out, "label2", "Distance");
sf_putstring(out, "unit2" , "km");
if (pas) {
sf_putint (out, "n3", nt);
sf_putfloat (out, "d3", dt);
sf_putfloat (out, "o3", 0.0f);
sf_putstring(out, "label3", "Time");
sf_putstring(out, "unit3" , "s");
}
}else{ /* modeling */
if(!sf_getint("nt", &nt)) sf_error("Need nt=");
if(!sf_getfloat("dt", &dt)) sf_error("Need dt=");
sf_putint (out, "n1", nt);
sf_putfloat (out, "d1", dt);
sf_putfloat (out, "o1", 0.0);
sf_putstring(out, "label1", "Time");
sf_putstring(out, "unit1" , "s");
sf_putint (out, "n2", nx);
sf_putfloat (out, "o2", ox);
sf_putfloat (out, "d2", dx);
sf_putstring(out, "label2", "Distance");
sf_putstring(out, "unit2" , "km");
if (pas) {
sf_putint (out, "n3", 1);
}
}
/* dimension of padded boundary */
if(!sf_getint("nb", &nb) || nb<NOP) nb = NOP;
if(!sf_getfloat("cb", &cb)) cb = 0.0f;
nxpad = nx+2*nb;
nzpad = nz+2*nb;
nzxpad = nzpad*nxpad;
depth = depth+nb;
/* set Laplacian coefficients */
idz2 = 1.0f/(dz*dz);
idx2 = 1.0f/(dx*dx);
/* wavefield snapshot */
if(snap){
wave = sf_output("wave");
sf_putint(wave, "n1", nzpad);
sf_putfloat(wave, "d1", dz);
sf_putfloat(wave, "o1", oz-nb*dz);
sf_putint(wave, "n2", nxpad);
sf_putfloat(wave, "d2", dx);
sf_putfloat(wave, "o2", ox-nb*dx);
sf_putint(wave, "n3", 1+(nt-1)/snap);
if(adj){
sf_putfloat(wave, "d3", -snap*dt);
sf_putfloat(wave, "o3", (nt-1)*dt);
}else{
sf_putfloat(wave, "d3", snap*dt);
sf_putfloat(wave, "o3", 0.0f);
}
}
/* allocate arrays */
vv = sf_floatalloc2(nz, nx);
dd = sf_floatalloc2(nt, nx);
vvpad = sf_floatalloc2(nzpad, nxpad);
u0 = sf_floatalloc2(nzpad, nxpad);
u1 = sf_floatalloc2(nzpad, nxpad);
u2 = sf_floatalloc2(nzpad, nxpad);
if (pas) {
mm = NULL;
ww = sf_floatalloc3(nz, nx, nt);
} else {
mm = sf_floatalloc2(nz, nx);
ww = NULL;
}
/* read velocity */
sf_floatread(vv[0], nz*nx, vel);
/* pad boundary */
dt2 = dt*dt;
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
vvpad[ix+nb][iz+nb] = vv[ix][iz]*vv[ix][iz]*dt2;
for (ix=0; ix<nxpad; ix++){
for (iz=0; iz<nb; iz++){
vvpad[ix][ iz ] = vvpad[ix][ nb ];
vvpad[ix][nzpad-iz-1] = vvpad[ix][nzpad-nb-1];
}
}
for (ix=0; ix<nb; ix++){
for (iz=0; iz<nzpad; iz++){
vvpad[ ix ][iz]=vvpad[ nb ][iz];
vvpad[nxpad-ix-1][iz]=vvpad[nxpad-nb-1][iz];
}
}
memset(u0[0], 0.0f, nzxpad*sizeof(float));
memset(u1[0], 0.0f, nzxpad*sizeof(float));
memset(u2[0], 0.0f, nzxpad*sizeof(float));
/* absorbing boundary condition */
if (abc) {
if (verb) sf_warning("absorbing boundary condition");
abc_init(nzpad,nxpad,nzpad,nxpad,nb,nb,nb,nb,cb,cb,cb,cb);
}
if(adj){ /* migration */
/* read data */
sf_floatread(dd[0], nt*nx, in);
for (it=nt-1; it>-1; it--){
if (verb) sf_warning("Migration: %d/%d;", it, 0);
/* time stepping */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=NOP; ix<nxpad-NOP; ix++){
for (iz=NOP; iz<nzpad-NOP; iz++){
u2[ix][iz] = LapT(u1,ix,iz,idx2,idz2,vvpad) + 2.0f*u1[ix][iz] - u0[ix][iz];
}
}
/* rotate pointers */
tmp=u0; u0=u1; u1=u2; u2=tmp;
if (abc) abc_apply(u1[0]);
if (abc) abc_apply(u0[0]);
/* inject data */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix)
#endif
for (ix=nb; ix<nb+nx; ix++)
u1[ix][depth] += dd[ix-nb][it];
if (pas) {
/* image source */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
ww[it][ix][iz] = u1[ix+nb][iz+nb];
}
if (snap && it%snap==0) sf_floatwrite(u1[0], nzxpad, wave);
}
if (verb) sf_warning(".");
if (!pas) {
/* output image */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
mm[ix][iz] = u1[ix+nb][iz+nb];
sf_floatwrite(mm[0], nz*nx, out);
} else {
/* output source */
sf_floatwrite(ww[0][0], nz*nx*nt, out);
}
}else{/* modeling */
if (pas) {
/* read source */
sf_floatread(ww[0][0], nz*nx*nt, in);
} else {
/* read image */
sf_floatread(mm[0], nz*nx, in);
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
u1[ix+nb][iz+nb] = mm[ix][iz];
}
for (it=0; it<nt; it++){
if (verb) sf_warning("Modeling: %d/%d;", it, nt-1);
if(snap && it%snap==0) sf_floatwrite(u1[0], nzxpad, wave);
if (pas){
/* inject source */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=0; ix<nx; ix++)
for (iz=0; iz<nz; iz++)
u1[ix+nb][iz+nb] += ww[it][ix][iz];
}
/* record data */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix)
#endif
for (ix=nb; ix<nb+nx; ix++)
dd[ix-nb][it] = u1[ix][depth];
if (abc) abc_apply(u0[0]);
if (abc) abc_apply(u1[0]);
/* time stepping */
#ifdef _OPENMP
#pragma omp parallel for default(shared) private(ix, iz)
#endif
for (ix=NOP; ix<nxpad-NOP; ix++){
for (iz=NOP; iz<nzpad-NOP; iz++){
u2[ix][iz] = Lap (u1,ix,iz,idx2,idz2,vvpad) + 2.0f*u1[ix][iz] - u0[ix][iz];
}
}
/* rotate pointers */
tmp=u0; u0=u1; u1=u2; u2=tmp;
}
if (verb) sf_warning(".");
/* output data */
sf_floatwrite(dd[0], nt*nx, out);
}
if(pas) {
free(**ww); free(*ww); free(ww);
} else {
free(*mm); free(mm);
}
if (abc) abc_close();
free(*vvpad); free(vvpad); free(*vv); free(vv);
free(*dd); free(dd);
free(*u0); free(u0); free(*u1); free(u1); free(*u2); free(u2);
exit (0);
}
int main(int argc, char* argv[])
{
int i;
float *data;
char *fn;
sf_init(argc,argv);
FILE *Fi;
sf_file Fo;
cjbsegy *tr;
tr = calloc(sizeof(cjbsegy), 1);
int nx, ny, nazim, nang, ntau;
float dazim, dang, dtau, fazim=0.0, fang=0.0, ftau=0;
int dx, dy, fx=0, fy=0;
if (!sf_getint("nx",&nx)) nx=101;
if (!sf_getint("ny",&ny)) ny=101;
if (!sf_getint("nazim",&nazim)) nazim=8;
if (!sf_getint("nang",&nang)) nang=21;
if (!sf_getint("ntau",&ntau)) ntau=101;
if (!sf_getint("dx",&dx)) dx=1;
if (!sf_getint("dy",&dy)) dy=1;
if (!sf_getfloat("dazim",&dazim)) dazim=22.5;
if (!sf_getfloat("dang",&dang)) dang=2.0;
if (!sf_getfloat("dtau",&dtau)) dtau=0.002;
if (!sf_getint("fx",&fx)) fx=1;
if (!sf_getint("fy",&fy)) fy=1;
if (!sf_getfloat("ftau",&ftau)) ftau=0;
if (NULL==(fn=sf_getstring("fn"))) fn="kpstm.ladcig.su.agc";
/* setup I/O files */
Fo = sf_output("out");
if((Fi=fopen(fn,"rb"))==NULL)
{
printf("File %s open error!\n",fn);
exit(0);
}
fread(tr,sizeof(cjbsegy),1,Fi);
int iline0=tr->ep;
sf_warning("ns=%d dt=%f iLineNo=%d ",tr->ns, tr->dt,iline0);
if(fseek(Fi, 0L, 2) ==-1)
printf("input file size unknown; Please specify n2\n");
int nxy=(int) (ftell(Fi)/((60+ntau)*sizeof(float)));
sf_warning("nxy=%d nx=%d ny=%d ",nxy, nx,ny);
sf_warning("nazim=%d nang=%d ntau=%d",nazim,nang,ntau);
sf_warning("dx=%d dy=%d dazim=%f dang=%f dtau=%f",dx,dy,dazim,dang,dtau);
sf_warning("fx=%d fy=%d fazim=%f fang=%f ftau=%f",fx,fy,fazim,fang,ftau);
if(nxy!=nx*ny*nazim*nang) {
sf_warning("nx * ny * nazim * nang != nxy ");
exit(0);
};
sf_putint(Fo,"n1",ntau);
sf_putint(Fo,"n2",nang);
sf_putint(Fo,"n3",nazim);
sf_putint(Fo,"n4",nx);
sf_putint(Fo,"n5",ny);
sf_putfloat(Fo,"d1",dtau);
sf_putfloat(Fo,"o1",ftau);
sf_putfloat(Fo,"d2",dang);
sf_putfloat(Fo,"o2",fang);
sf_putfloat(Fo,"d3",dazim);
sf_putfloat(Fo,"o3",fazim);
sf_putfloat(Fo,"d4",dx);
sf_putfloat(Fo,"o4",fx);
sf_putfloat(Fo,"d5",dy);
sf_putfloat(Fo,"o5",fy);
sf_putstring(Fo,"label1","z");
sf_putstring(Fo,"label2","angle");
sf_putstring(Fo,"label3","azimuth");
sf_putstring(Fo,"label4","x");
sf_putstring(Fo,"label5","y");
sf_putstring(Fo,"unit1","ms");
sf_putstring(Fo,"unit2","degree");
sf_putstring(Fo,"unit3","degree");
sf_putstring(Fo,"unit4","m");
sf_putstring(Fo,"unit5","m");
data = sf_floatalloc(ntau);
rewind(Fi);
for(i=0;;i++)
{
fread(tr,sizeof(cjbsegy),1,Fi);
if(tr->ep != iline0){
sf_warning("Read iLineNo=%d finished",iline0);
iline0=tr->ep;
}
fread(data,sizeof(float),ntau,Fi);
if(feof(Fi))break;
sf_floatwrite(data, ntau, Fo);
}
sf_warning("Read iLineNo=%d finished",tr->ep);
fclose(Fi);
free(data);
free(tr);
exit(0);
}
int main(int argc, char* argv[])
{
bool adj,timer,verb,gmres;
int nt, nx, nz, nx2, nz2, nzx, nzx2, ntx, pad1, snap, gpz, wfnt, i;
int m2, n2, nk, nth=1;
int niter, mem;
float dt, dx, dz, ox;
sf_complex *img, *imgout, *dat, **lt1, **rt1, **lt2, **rt2, ***wvfld;
sf_file data, image, leftf, rightf, leftb, rightb, snaps;
double time=0.,t0=0.,t1=0.;
geopar geop;
sf_init(argc,argv);
/* essentially doing imaging */
adj = true;
if (!sf_getbool("gmres",&gmres)) gmres=false;
if (gmres) {
if (!sf_getint("niter",&niter)) niter=10;
if (!sf_getint("mem",&mem)) mem=20;
}
if(! sf_getbool("timer",&timer)) timer=false;
if (!sf_getbool("verb",&verb)) verb=false;
if (!sf_getint("snap",&snap)) snap=0;
/* interval for snapshots */
if (!sf_getint("pad1",&pad1)) pad1=1;
/* padding factor on the first axis */
if(!sf_getint("gpz",&gpz)) gpz=0;
/* geophone surface */
/* adj */
if (!sf_getint("nz",&nz)) sf_error("Need nz=");
/* depth samples */
if (!sf_getfloat("dz",&dz)) sf_error("Need dz=");
/* depth sampling */
/* for */
if (!sf_getint("nt",&nt)) sf_error("Need nt=");
/* time samples */
if (!sf_getfloat("dt",&dt)) sf_error("Need dt=");
/* time sampling */
if (adj) { /* migration */
data = sf_input("in");
image = sf_output("out");
sf_settype(image,SF_COMPLEX);
if (!sf_histint(data,"n1",&nt)) sf_error("No n1= in input");
if (!sf_histfloat(data,"d1",&dt)) sf_error("No d1= in input");
if (!sf_histint(data,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histfloat(data,"d2",&dx)) sf_error("No d2= in input");
if (!sf_histfloat(data,"o2",&ox)) ox=0.;
sf_putint(image,"n1",nz);
sf_putfloat(image,"d1",dz);
sf_putfloat(image,"o1",0.);
sf_putstring(image,"label1","Depth");
sf_putint(image,"n2",nx);
sf_putfloat(image,"d2",dx);
sf_putfloat(image,"o2",ox);
sf_putstring(image,"label2","Distance");
} else { /* modeling */
image = sf_input("in");
data = sf_output("out");
sf_settype(data,SF_COMPLEX);
if (!sf_histint(image,"n1",&nz)) sf_error("No n1= in input");
if (!sf_histfloat(image,"d1",&dz)) sf_error("No d1= in input");
if (!sf_histint(image,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histfloat(image,"d2",&dx)) sf_error("No d2= in input");
if (!sf_histfloat(image,"o2",&ox)) ox=0.;
if (!sf_getint("nt",&nt)) sf_error("Need nt=");
/* time samples */
if (!sf_getfloat("dt",&dt)) sf_error("Need dt=");
/* time sampling */
sf_putint(data,"n1",nt);
sf_putfloat(data,"d1",dt);
sf_putfloat(data,"o1",0.);
sf_putstring(data,"label1","Time");
sf_putstring(data,"unit1","s");
sf_putint(data,"n2",nx);
sf_putfloat(data,"d2",dx);
sf_putfloat(data,"o2",ox);
sf_putstring(data,"label2","Distance");
}
nz2 = kiss_fft_next_fast_size(nz*pad1);
nx2 = kiss_fft_next_fast_size(nx);
nk = nz2*nx2; /*wavenumber*/
nzx = nz*nx;
nzx2 = nz2*nx2;
ntx = nt*nx;
if (snap > 0) {
wfnt = (int)(nt-1)/snap+1;
snaps = sf_output("snaps");
/* (optional) snapshot file */
sf_settype(snaps,SF_COMPLEX);
sf_putint(snaps,"n1",nz);
sf_putfloat(snaps,"d1",dz);
sf_putfloat(snaps,"o1",0.);
sf_putstring(snaps,"label1","Depth");
sf_putint(snaps,"n2",nx);
sf_putfloat(snaps,"d2",dx);
sf_putfloat(snaps,"o2",ox);
sf_putstring(snaps,"label2","Distance");
sf_putint(snaps,"n3",wfnt);
sf_putfloat(snaps,"d3",dt*snap);
sf_putfloat(snaps,"o3",0.);
sf_putstring(snaps,"label3","Time");
} else {
wfnt = 0;
snaps = NULL;
}
/* propagator matrices */
leftf = sf_input("leftf");
rightf = sf_input("rightf");
if (!sf_histint(leftf,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in leftf",nzx);
if (!sf_histint(leftf,"n2",&m2)) sf_error("No n2= in leftf");
if (!sf_histint(rightf,"n1",&n2) || n2 != m2) sf_error("Need n1=%d in rightf",m2);
if (!sf_histint(rightf,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in rightf",nk);
leftb = sf_input("leftb");
rightb = sf_input("rightb");
if (!sf_histint(leftb,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in leftb",nzx);
if (!sf_histint(leftb,"n2",&m2)) sf_error("No n2= in leftb");
if (!sf_histint(rightb,"n1",&n2) || n2 != m2) sf_error("Need n1=%d in rightb",m2);
if (!sf_histint(rightb,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in rightb",nk);
lt1 = sf_complexalloc2(nzx,m2); /* propagator for forward modeling */
rt1 = sf_complexalloc2(m2,nk);
lt2 = sf_complexalloc2(nzx,m2); /* propagator for backward imaging */
rt2 = sf_complexalloc2(m2,nk);
img = sf_complexalloc(nz*nx);
dat = sf_complexalloc(nt*nx);
imgout = sf_complexalloc(nz*nx);
if (snap > 0) wvfld = sf_complexalloc3(nz,nx,wfnt);
else wvfld = NULL;
geop = (geopar) sf_alloc(1, sizeof(*geop));
sf_complexread(lt1[0],nzx*m2,leftf);
sf_complexread(rt1[0],m2*nk,rightf);
sf_complexread(lt2[0],nzx*m2,leftb);
sf_complexread(rt2[0],m2*nk,rightb);
if (adj) sf_complexread(dat,ntx,data);
else sf_complexread(img,nzx,image);
/*close RSF files*/
sf_fileclose(leftf);
sf_fileclose(rightf);
sf_fileclose(leftb);
sf_fileclose(rightb);
#ifdef _OPENMP
#pragma omp parallel
{
nth = omp_get_num_threads();
}
sf_warning(">>>> Using %d threads <<<<<", nth);
#endif
if (timer) t0 = gtod_timer();
/*load constant geopar elements*/
geop->nx = nx;
geop->nz = nz;
geop->dx = dx;
geop->dz = dz;
geop->ox = ox;
geop->gpz = gpz;
geop->nt = nt;
geop->dt = dt;
geop->snap= snap;
geop->nzx2= nzx2;
geop->nk = nk;
geop->m2 = m2;
geop->wfnt= wfnt;
geop->pad1= pad1;
geop->verb= verb;
/* first get the Q-compensated image: B[d] */
lrexp(img, dat, adj, lt2, rt2, geop, wvfld);
/* performing the least-squares optimization: ||{BF}[m] - B[d]|| */
if (gmres) {
/* disabling snapshots */
geop->snap= 0;
lrexp_init(lt1,rt1,lt2,rt2);
sf_warning(">>>>>> Using GMRES(m) <<<<<<");
cgmres_init(nzx,mem);
cgmres( img, imgout, lrexp_op, geop, niter, 0.01*SF_EPS, true);
/*lrexp_op(nzx, img, imgout, geop);*/
lrexp_close();
} else {
for (i=0; i<nzx; i++)
imgout[i] = img[i];
}
if (timer)
{
t1 = gtod_timer();
time = t1-t0;
sf_warning("Time = %lf\n",time);
}
if (adj) {
sf_complexwrite(imgout,nzx,image);
} else {
sf_complexwrite(dat,ntx,data);
}
if (snap > 0 && NULL != snaps) {
sf_complexwrite(wvfld[0][0],wfnt*nx*nz,snaps);
}
exit(0);
}
int main(int argc, char* argv[])
{
bool inv, verb;
int i1, n1, iw, nt, nw, i2, n2, rect0, niter, n12, n1w;
int m[SF_MAX_DIM], *rect;
float t, d1, w, w0, dw, mean=0.0f, alpha;
float *trace, *kbsc, *mkbsc, *sscc, *mm, *ww;
sf_complex *outp, *cbsc;
sf_file in, out, mask, weight, basis;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histfloat(in,"d1",&d1)) d1=1.;
if (!sf_getbool("inv",&inv)) inv=false;
/* if y, do inverse transform */
if (!sf_getbool("verb",&verb)) verb = false;
/* verbosity flag */
if (NULL != sf_getstring("basis")) {
basis = sf_output("basis");
sf_settype(basis,SF_COMPLEX);
} else {
basis = NULL;
}
if (!inv) {
if (!sf_getint("nw",&nw)) { /* number of frequencies */
nt = 2*kiss_fft_next_fast_size((n1+1)/2);
nw = nt/2+1;
dw = 1./(nt*d1);
w0 = 0.;
} else {
if (!sf_getfloat("dw",&dw)) {
/* frequency step */
nt = 2*kiss_fft_next_fast_size((n1+1)/2);
dw = 1./(nt*d1);
}
if (!sf_getfloat("w0",&w0)) w0=0.;
/* first frequency */
}
n2 = sf_leftsize(in,1);
sf_shiftdim(in, out, 2);
sf_putint(out,"n2",nw);
sf_putfloat(out,"d2",dw);
sf_putfloat(out,"o2",w0);
sf_putstring(out,"label2","Frequency");
sf_putstring(out,"unit2","Hz");
sf_settype(out,SF_COMPLEX);
if (!sf_getint("rect",&rect0)) rect0=10;
/* smoothing radius (in time, samples) */
if (!sf_getint("niter",&niter)) niter=100;
/* number of inversion iterations */
if (!sf_getfloat("alpha",&alpha)) alpha=0.;
/* frequency adaptivity */
for(i2=0; i2 < SF_MAX_DIM; i2 ++) {
m[i2] = 1;
}
m[0] = n1;
} else {
n2 = sf_leftsize(in,2);
if (!sf_histint(in,"n2",&nw)) sf_error("No n2= in input");
if (!sf_histfloat(in,"d2",&dw)) sf_error("No d2= in input");
if (!sf_histfloat(in,"o2",&w0)) sf_error("No o2= in input");
sf_unshiftdim(in, out, 2);
sf_settype(out,SF_FLOAT);
}
if (NULL != basis) {
sf_shiftdim(in, basis, 2);
sf_putint(basis,"n2",nw);
sf_putfloat(basis,"d2",dw);
sf_putfloat(basis,"o2",w0);
sf_putstring(basis,"label2","Frequency");
sf_putstring(basis,"unit2","Hz");
}
n1w = n1*nw;
n12 = 2*n1w;
dw *= 2.*SF_PI;
w0 *= 2.*SF_PI;
trace = sf_floatalloc(n1);
kbsc = sf_floatalloc(n12);
outp = sf_complexalloc(n1w);
cbsc = sf_complexalloc(n1w);
rect = sf_intalloc(2*nw);
for (iw=0; iw < nw; iw++) {
rect[iw+nw] = rect[iw] = SF_MAX(1, (int) rect0/(1.0+alpha*iw/nw));
}
if (!inv) {
sscc = sf_floatalloc(n12);
nmultidivn_init(2*nw, 1, n1, m, rect, kbsc,
(bool) (verb && (n2 < 500)));
} else {
sscc = NULL;
}
if (NULL != sf_getstring("mask")) { /* data weight */
mask = sf_input("mask");
mm = sf_floatalloc(n1);
} else {
mask = NULL;
mm = NULL;
}
if (NULL != sf_getstring("weight")) { /* model weight */
weight = sf_input("weight");
ww = sf_floatalloc(n1w);
} else {
weight = NULL;
ww = NULL;
}
/* sin and cos basis */
for (iw=0; iw < nw; iw++) {
w = w0 + iw*dw;
for (i1=0; i1 < n1; i1++) {
if (0.==w) { /* zero frequency */
kbsc[iw*n1+i1] = 0.;
} else {
t = i1*d1;
kbsc[iw*n1+i1] = sinf(w*t);
}
}
}
for (iw=0; iw < nw; iw++) {
w = w0 + iw*dw;
for (i1=0; i1 < n1; i1++) {
if (0.==w) { /* zero frequency */
kbsc[(iw+nw)*n1+i1] = 0.5;
} else {
t = i1*d1;
kbsc[(iw+nw)*n1+i1] = cosf(w*t);
}
cbsc[iw*n1+i1] = sf_cmplx(kbsc[(iw+nw)*n1+i1],
kbsc[iw*n1+i1]);
}
}
if (NULL != mm || NULL != ww) {
mkbsc = sf_floatalloc(n12);
for (i1=0; i1 < n12; i1++) {
mkbsc[i1] = kbsc[i1];
}
} else {
mkbsc = NULL;
mean = 0.;
for (i1=0; i1 < n12; i1++) {
mean += kbsc[i1]*kbsc[i1];
}
mean = sqrtf (mean/(n12));
for (i1=0; i1 < n12; i1++) {
kbsc[i1] /= mean;
}
}
for (i2=0; i2 < n2; i2++) {
sf_warning("slice %d of %d;",i2+1,n2);
if (NULL != basis) sf_complexwrite(cbsc,n1w,basis);
if (NULL != mm || NULL != ww) {
for (i1=0; i1 < n12; i1++) {
kbsc[i1] = mkbsc[i1];
}
if (NULL != mm) {
sf_floatread(mm,n1,mask);
for (iw=0; iw < 2*nw; iw++) {
for (i1=0; i1 < n1; i1++) {
kbsc[iw*n1+i1] *= mm[i1];
}
}
}
if (NULL != ww) {
sf_floatread(ww,n1w,weight);
for (iw=0; iw < nw; iw++) {
for (i1=0; i1 < n1; i1++) {
kbsc[iw*n1+i1] *= ww[iw*n1+i1];
kbsc[(iw+nw)*n1+i1] *= ww[iw*n1+i1];
}
}
}
mean = 0.;
for (i1=0; i1 < n12; i1++) {
mean += kbsc[i1]*kbsc[i1];
}
mean = sqrtf (mean/(n12));
for (i1=0; i1 < n12; i1++) {
kbsc[i1] /= mean;
}
}
if (!inv) {
sf_floatread(trace,n1,in);
if (NULL != mm) {
for (i1=0; i1 < n1; i1++) {
trace[i1] *= mm[i1];
}
}
for(i1=0; i1 < n1; i1++) {
trace[i1] /= mean;
}
nmultidivn (trace,sscc,niter);
for (iw=0; iw < nw; iw++) {
for (i1=0; i1 < n1; i1++) {
outp[iw*n1+i1] = sf_cmplx(sscc[(iw+nw)*n1+i1],
sscc[iw*n1+i1]);
}
}
if (NULL != ww) {
for (i1=0; i1 < n1w; i1++) {
#ifdef SF_HAS_COMPLEX_H
outp[i1] *= ww[i1];
#else
outp[i1] = sf_crmul(outp[i1],ww[i1]);
#endif
}
}
sf_complexwrite(outp,n1w,out);
} else {
for (i1=0; i1 < n1; i1++) {
trace[i1] = 0.;
}
sf_complexread(outp,n1w,in);
for (iw=0; iw < nw; iw++) {
for (i1=0; i1 < n1; i1++) {
trace[i1] += crealf(outp[iw*n1+i1])*kbsc[(iw+nw)*n1+i1]
*mean+cimagf(outp[iw*n1+i1])*kbsc[iw*n1+i1]*mean;
if (NULL != mm) trace[i1] *= mm[i1];
}
}
sf_floatwrite(trace,n1,out);
}
}
sf_warning(".");
exit(0);
}
int main(int argc, char* argv[])
{
bool adj,timer,verb;
int nt, nx, nz, nx2, nz2, nzx, nzx2, ntx, pad1, snap, wfnt;
int m2, n2, nk, nth=1;
float dt, dx, dz, ox;
sf_complex **img, **dat, **lt, **rt, ***wvfld, *ww;
sf_file data, image, left, right, snaps, src;
double time=0.,t0=0.,t1=0.;
geopar geop;
sf_init(argc,argv);
if (!sf_getbool("adj",&adj)) adj=false;
/* if n, modeling; if y, migration */
if(! sf_getbool("timer",&timer)) timer=false;
if (!sf_getbool("verb",&verb)) verb=false;
if (!sf_getint("snap",&snap)) snap=0;
/* interval for snapshots */
if (!sf_getint("pad1",&pad1)) pad1=1;
/* padding factor on the first axis */
if (adj) { /* migration */
data = sf_input("in"); // data here is just a refl file
image = sf_output("out");
sf_settype(image,SF_COMPLEX);
if (!sf_histint(data,"n1",&nz)) sf_error("No n1= in input");
if (!sf_histfloat(data,"d1",&dz)) sf_error("No d1= in input");
if (!sf_histint(data,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histfloat(data,"d2",&dx)) sf_error("No d2= in input");
if (!sf_histfloat(data,"o2",&ox)) ox=0.;
if (!sf_getint("nt",&nt)) sf_error("Need nt=");
/* time samples */
if (!sf_getfloat("dt",&dt)) sf_error("Need dt=");
/* time sampling */
sf_putint(image,"n1",nz);
sf_putfloat(image,"d1",dz);
sf_putfloat(image,"o1",0.);
sf_putstring(image,"label1","Depth");
sf_putint(image,"n2",nx);
sf_putfloat(image,"d2",dx);
sf_putfloat(image,"o2",ox);
sf_putstring(image,"label2","Distance");
} else { /* modeling */
image = sf_input("in");
data = sf_output("out");
src = sf_input("src");
sf_settype(data,SF_COMPLEX);
if (!sf_histint(image,"n1",&nz)) sf_error("No n1= in input");
if (!sf_histfloat(image,"d1",&dz)) sf_error("No d1= in input");
if (!sf_histint(image,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histfloat(image,"d2",&dx)) sf_error("No d2= in input");
if (!sf_histfloat(image,"o2",&ox)) ox=0.;
if (!sf_getint("nt",&nt)) sf_error("Need nt=");
/* time samples */
if (!sf_getfloat("dt",&dt)) sf_error("Need dt=");
/* time sampling */
if (!sf_histint(src,"n1",&n2) || n2 != nt) sf_error("nt doesn't match!");
sf_putint(data,"n1",nz);
sf_putfloat(data,"d1",dz);
sf_putfloat(data,"o1",0.);
sf_putstring(data,"label1","Depth");
sf_putint(data,"n2",nx);
sf_putfloat(data,"d2",dx);
sf_putfloat(data,"o2",ox);
sf_putstring(data,"label2","Distance");
}
nz2 = kiss_fft_next_fast_size(nz*pad1);
nx2 = kiss_fft_next_fast_size(nx);
nk = nz2*nx2; /*wavenumber*/
nzx = nz*nx;
nzx2 = nz2*nx2;
ntx = nt*nx;
wfnt = (int)(nt-1)/snap+1;
if (snap > 0) {
snaps = sf_output("snaps");
/* (optional) snapshot file */
sf_settype(snaps,SF_COMPLEX);
sf_putint(snaps,"n1",nz);
sf_putfloat(snaps,"d1",dz);
sf_putfloat(snaps,"o1",0.);
sf_putstring(snaps,"label1","Depth");
sf_putint(snaps,"n2",nx);
sf_putfloat(snaps,"d2",dx);
sf_putfloat(snaps,"o2",ox);
sf_putstring(snaps,"label2","Distance");
sf_putint(snaps,"n3",wfnt);
sf_putfloat(snaps,"d3",dt*snap);
sf_putfloat(snaps,"o3",0.);
sf_putstring(snaps,"label3","Time");
} else {
snaps = NULL;
}
/* propagator matrices */
left = sf_input("left");
right = sf_input("right");
if (!sf_histint(left,"n1",&n2) || n2 != nzx) sf_error("Need n1=%d in left",nzx);
if (!sf_histint(left,"n2",&m2)) sf_error("No n2= in left");
if (!sf_histint(right,"n1",&n2) || n2 != m2) sf_error("Need n1=%d in right",m2);
if (!sf_histint(right,"n2",&n2) || n2 != nk) sf_error("Need n2=%d in right",nk);
lt = sf_complexalloc2(nzx,m2);
rt = sf_complexalloc2(m2,nk);
img = sf_complexalloc2(nz,nx);
dat = sf_complexalloc2(nz,nx);
if (snap > 0) wvfld = sf_complexalloc3(nz,nx,wfnt);
else wvfld = NULL;
geop = (geopar) sf_alloc(1, sizeof(*geop));
if (!adj) {
ww=sf_complexalloc(nt);
sf_complexread(ww,nt,src);
} else ww=NULL;
sf_complexread(lt[0],nzx*m2,left);
sf_complexread(rt[0],m2*nk,right);
if (adj) sf_complexread(dat[0],nzx,data);
else sf_complexread(img[0],nzx,image);
/*close RSF files*/
sf_fileclose(left);
sf_fileclose(right);
#ifdef _OPENMP
#pragma omp parallel
{
nth = omp_get_num_threads();
}
sf_warning(">>>> Using %d threads <<<<<", nth);
#endif
if (timer) t0 = gtod_timer();
/*load constant geopar elements*/
geop->nx = nx;
geop->nz = nz;
geop->dx = dx;
geop->dz = dz;
geop->ox = ox;
geop->nt = nt;
geop->dt = dt;
geop->snap= snap;
geop->nzx2= nzx2;
geop->nk = nk;
geop->m2 = m2;
geop->wfnt= wfnt;
lrexp(img, dat, adj, lt, rt, ww, geop, pad1, verb, snap, wvfld);
if (timer)
{
t1 = gtod_timer();
time = t1-t0;
sf_warning("Time = %lf\n",time);
}
if (adj) {
sf_complexwrite(img[0],nzx,image);
} else {
sf_complexwrite(dat[0],ntx,data);
}
if (snap > 0 && NULL != snaps) {
sf_complexwrite(wvfld[0][0],wfnt*nx*nz,snaps);
}
exit(0);
}
int main (int argc, char* argv[]) {
int nz, nx, ny, nb, na, ib, ia, iz, ix, iy, i, it, nt, ic, nc = 1, fz, lz, itr = 0;
float dz, oz, dx, ox, dy, oy, db, ob, da, oa, z, x, y, a, dt, df, md, aper;
float ****e;
sf_file spdom, vspline = NULL, out, traj = NULL;
sf_escrt3_traj_cbud *tdata = NULL;
char *ext = NULL;
bool verb, parab;
sf_esc_slowness3 esc_slow;
sf_esc_tracer3 *esc_tracers;
sf_esc_point3 *esc_points;
sf_timer timer;
sf_init (argc, argv);
if (!sf_stdin ()) {
spdom = NULL;
} else {
spdom = sf_input ("in");
/* Spatial (z,x,y) domain */
}
out = sf_output ("out");
/* Escape values */
/* Spatial dimensions */
if (spdom) {
if (!sf_histint (spdom, "n1", &nz)) sf_error ("No n1= in input");
if (!sf_histint (spdom, "n2", &nx)) sf_error ("No n2= in input");
if (!sf_histint (spdom, "n3", &ny)) sf_error ("No n3= in input");
if (!sf_histfloat (spdom, "d1", &dz)) sf_error ("No d1= in input");
if (!sf_histfloat (spdom, "o1", &oz)) sf_error ("No o1= in input");
if (!sf_histfloat (spdom, "d2", &dx)) sf_error ("No d2= in input");
if (!sf_histfloat (spdom, "o2", &ox)) sf_error ("No o2= in input");
if (!sf_histfloat (spdom, "d3", &dy)) sf_error ("No d3= in input");
if (!sf_histfloat (spdom, "o3", &oy)) sf_error ("No o3= in input");
}
ext = sf_escrt3_warnext (spdom);
if (!sf_getint ("nz", &nz) && !spdom) sf_error ("Need nz=");
/* Number of samples in z axis */
if (!sf_getfloat ("oz", &oz) && !spdom) sf_error ("Need oz=");
/* Beginning of z axis */
if (!sf_getfloat ("dz", &dz) && !spdom) sf_error ("Need dz=");
/* Sampling of z axis */
if (!sf_getint ("nx", &nx) && !spdom) sf_error ("Need nx=");
/* Number of samples in x axis */
if (!sf_getfloat ("ox", &ox) && !spdom) sf_error ("Need ox=");
/* Beginning of x axis */
if (!sf_getfloat ("dx", &dx) && !spdom) sf_error ("Need dx=");
/* Sampling of x axis */
if (!sf_getint ("ny", &ny) && !spdom) sf_error ("Need ny=");
/* Number of samples in y axis */
if (!sf_getfloat ("oy", &oy) && !spdom) sf_error ("Need oy=");
/* Beginning of y axis */
if (!sf_getfloat ("dy", &dy) && !spdom) sf_error ("Need dy=");
/* Sampling of y axis */
if (!sf_getint ("na", &na)) na = 360;
/* Number of azimuth phase angles */
da = 2.0*SF_PI/(float)na;
oa = 0.5*da;
if (!sf_getint ("nb", &nb)) nb = 180;
/* Number of inclination phase angles */
db = SF_PI/(float)nb;
ob = 0.5*db;
if (!sf_getfloat ("df", &df)) df = 0.1;
/*< Maximum distance to travel per step (fraction of the cell size) >*/
if (!sf_getfloat ("md", &md)) md = SF_HUGE;
/* Maximum distance for a ray to travel (default - up to model boundaries) */
if (md != SF_HUGE)
md = fabsf (md);
if (!sf_getfloat ("aper", &aper)) aper = SF_HUGE;
/* Maximum aperture in x and y directions from current point (default - up to model boundaries) */
if (aper != SF_HUGE)
aper = fabsf (aper);
#ifdef _OPENMP
if (!sf_getint ("nc", &nc)) nc = 0;
/* Number of threads to use for ray tracing (OMP_NUM_THREADS by default) */
if (nc)
omp_set_num_threads (nc); /* User override */
else
nc = omp_get_max_threads (); /* Current default */
sf_warning ("%s Using %d threads", ext, omp_get_max_threads ());
#endif
if (!sf_getbool ("parab", ¶b)) parab = true;
/* y - use parabolic approximation of trajectories, n - straight line */
if (!sf_getbool ("verb", &verb)) verb = false;
/* verbosity flag */
if (sf_getstring ("traj")) {
/* Trajectory output */
traj = sf_output ("traj");
if (!sf_getint ("nt", &nt)) nt = 1001;
/* Number of time samples for each trajectory */
if (!sf_getfloat ("dt", &dt)) dt = 0.001;
/* Time sampling */
tdata = (sf_escrt3_traj_cbud*)sf_alloc (nc*na*nb, sizeof(sf_escrt3_traj_cbud));
for (itr = 0; itr < nc*na*nb; itr++) {
tdata[itr].it = 0;
tdata[itr].nt = nt;
tdata[itr].dt = dt;
tdata[itr].pnts = sf_floatalloc2 (TRAJ3_COMPS - 1, nt);
}
}
e = sf_floatalloc4 (ESC3_NUM, nb, na, nc);
if (!sf_getstring ("vspl")) sf_error ("Need vspl=");
/* Spline coefficients for velocity model */
vspline = sf_input ("vspl");
/* Slowness components module [(an)isotropic] */
esc_slow = sf_esc_slowness3_init (vspline, verb);
/* Make room for escape variables in output */
if (spdom)
sf_shiftdimn (spdom, out, 1, 3);
sf_putint (out, "n1", ESC3_NUM);
sf_putfloat (out, "o1", 0.0);
sf_putfloat (out, "d1", 1.0);
sf_putstring (out, "label1", "Escape variable");
sf_putstring (out, "unit1", "");
sf_putint (out, "n2", nb);
sf_putfloat (out, "d2", db*180.0/SF_PI);
sf_putfloat (out, "o2", ob*180.0/SF_PI);
sf_putstring (out, "label2", "Inclination");
sf_putstring (out, "unit2", "Degrees");
sf_putint (out, "n3", na);
sf_putfloat (out, "d3", da*180.0/SF_PI);
sf_putfloat (out, "o3", oa*180.0/SF_PI);
sf_putstring (out, "label3", "Azimuth");
sf_putstring (out, "unit3", "Degrees");
sf_putint (out, "n4", nz);
sf_putfloat (out, "o4", oz);
sf_putfloat (out, "d4", dz);
if (!spdom) {
sf_putstring (out, "label4", "Depth");
sf_putstring (out, "unit4", "");
}
sf_putint (out, "n5", nx);
sf_putfloat (out, "o5", ox);
sf_putfloat (out, "d5", dx);
if (!spdom) {
sf_putstring (out, "label5", "X");
sf_putstring (out, "unit5", "");
}
sf_putint (out, "n6", ny);
sf_putfloat (out, "o6", oy);
sf_putfloat (out, "d6", dy);
if (!spdom) {
sf_putstring (out, "label6", "Y");
sf_putstring (out, "unit6", "");
}
/* Save min/max possible escape values */
sf_putfloat (out, "Zmin", sf_esc_slowness3_oz (esc_slow));
sf_putfloat (out, "Zmax", sf_esc_slowness3_oz (esc_slow) +
(sf_esc_slowness3_nz (esc_slow) - 1)*
sf_esc_slowness3_dz (esc_slow));
sf_putfloat (out, "Xmin", sf_esc_slowness3_ox (esc_slow));
sf_putfloat (out, "Xmax", sf_esc_slowness3_ox (esc_slow) +
(sf_esc_slowness3_nx (esc_slow) - 1)*
sf_esc_slowness3_dx (esc_slow));
sf_putfloat (out, "Ymin", sf_esc_slowness3_oy (esc_slow));
sf_putfloat (out, "Ymax", sf_esc_slowness3_oy (esc_slow) +
(sf_esc_slowness3_ny (esc_slow) - 1)*
sf_esc_slowness3_dy (esc_slow));
if (traj) {
if (spdom)
sf_shiftdimn (spdom, traj, 1, 4);
sf_putint (traj, "n1", TRAJ3_COMPS - 1);
sf_putfloat (traj, "o1", 0.0);
sf_putfloat (traj, "d1", 1.0);
sf_putstring (traj, "label1", "Escape variable");
sf_putstring (traj, "unit1", "");
sf_putint (traj, "n2", nt);
sf_putfloat (traj, "o2", 0.0);
sf_putfloat (traj, "d2", dt);
sf_putstring (traj, "label2", "Time");
sf_putstring (traj, "unit2", "s");
sf_putint (traj, "n3", nb);
sf_putfloat (traj, "d3", db*180.0/SF_PI);
sf_putfloat (traj, "o3", ob*180.0/SF_PI);
sf_putstring (traj, "label3", "Inclination");
sf_putstring (traj, "unit3", "Degrees");
sf_putint (traj, "n4", na);
sf_putfloat (traj, "d4", da*180.0/SF_PI);
sf_putfloat (traj, "o4", oa*180.0/SF_PI);
sf_putstring (traj, "label4", "Azimuth");
sf_putstring (traj, "unit4", "Degrees");
sf_putint (traj, "n5", nz);
sf_putfloat (traj, "o5", oz);
sf_putfloat (traj, "d5", dz);
if (!spdom) {
sf_putstring (traj, "label5", "Depth");
sf_putstring (traj, "unit5", "");
}
sf_putint (traj, "n6", nx);
sf_putfloat (traj, "o6", ox);
sf_putfloat (traj, "d6", dx);
if (!spdom) {
sf_putstring (traj, "label6", "X");
sf_putstring (traj, "unit6", "");
}
sf_putint (traj, "n7", ny);
sf_putfloat (traj, "o7", oy);
sf_putfloat (traj, "d7", dy);
if (!spdom) {
sf_putstring (traj, "label7", "Y");
sf_putstring (traj, "unit7", "");
}
}
esc_tracers = (sf_esc_tracer3*)sf_alloc (nc, sizeof(sf_esc_tracer3));
esc_points = (sf_esc_point3*)sf_alloc (nc, sizeof(sf_esc_point3));
for (ic = 0; ic < nc; ic++) {
esc_tracers[ic] = sf_esc_tracer3_init (esc_slow);
sf_esc_tracer3_set_parab (esc_tracers[ic], parab);
if (md != SF_HUGE)
sf_esc_tracer3_set_mdist (esc_tracers[ic], md);
sf_esc_tracer3_set_df (esc_tracers[ic], df);
esc_points[ic] = sf_esc_point3_init ();
}
timer = sf_timer_init ();
/* Ray tracing loop */
for (iy = 0; iy < ny; iy++) {
y = oy + iy*dy;
/* Set aperture */
if (aper != SF_HUGE) {
for (ic = 0; ic < nc; ic++) {
sf_esc_tracer3_set_ymin (esc_tracers[ic], y - aper);
sf_esc_tracer3_set_ymax (esc_tracers[ic], y + aper);
}
}
for (ix = 0; ix < nx; ix++) {
x = ox + ix*dx;
/* Set aperture */
if (aper != SF_HUGE) {
for (ic = 0; ic < nc; ic++) {
sf_esc_tracer3_set_xmin (esc_tracers[ic], x - aper);
sf_esc_tracer3_set_xmax (esc_tracers[ic], x + aper);
}
}
if (verb)
sf_warning ("%s Shooting from lateral location %d of %d at y=%g, x=%g;",
ext, iy*nx + ix + 1, ny*nx, y, x);
/* Loop over chunks */
for (ic = 0; ic < (nz/nc + ((nz % nc) != 0)); ic++) {
fz = ic*nc;
lz = (ic + 1)*nc - 1;
if (lz >= nz)
lz = nz - 1;
sf_timer_start (timer);
#ifdef _OPENMP
#pragma omp parallel for \
schedule(static,1) \
private(iz,ia,ib,a,z,it,i,itr) \
shared(fz,lz,iy,ix,nb,na,nz,nx,ny,ob,oa,oz,ox,oy,db,da,dz,dx,dy,x,y,tdata,esc_tracers,esc_points,e,out,traj)
#endif
for (iz = fz; iz <= lz; iz++) {
z = oz + iz*dz;
for (ia = 0; ia < na; ia++) {
a = oa + ia*da;
for (ib = 0; ib < nb; ib++) {
if (traj) {
itr = (iz - fz)*na*nb + ia*nb + ib;
sf_esc_tracer3_set_trajcb (esc_tracers[iz - fz], sf_escrt3_traj, dt,
(void*)&tdata[itr]);
}
sf_esc_tracer3_compute (esc_tracers[iz - fz], z, x, y, ob + ib*db, a,
0.0, 0.0, esc_points[iz - fz], NULL, NULL);
/* Copy escape values to the output buffer */
for (i = 0; i < ESC3_NUM; i++)
e[iz - fz][ia][ib][i] = sf_esc_point3_get_esc_var (esc_points[iz - fz], i);
if (traj) {
/* Fill the rest of the trajectory with the last point */
for (it = tdata[itr].it + 1; it < tdata[itr].nt; it++) {
for (i = 0; i < TRAJ3_COMPS - 1; i++)
tdata[itr].pnts[it][i] = tdata[itr].pnts[tdata[itr].it][i];
}
}
} /* Loop over b */
} /* Loop over a */
} /* Loop over z */
sf_timer_stop (timer);
sf_floatwrite (e[0][0][0], (size_t)(lz - fz + 1)*(size_t)nb*(size_t)na*(size_t)ESC3_NUM,
out);
if (tdata) {
for (itr = 0; itr < (lz - fz + 1)*na*nb; itr++) {
sf_floatwrite (tdata[itr].pnts[0],
(size_t)tdata[itr].nt*(size_t)(TRAJ3_COMPS - 1), traj);
}
}
} /* Loop over z chunks */
} /* Loop over x */
} /* Loop over y */
if (verb) {
sf_warning (".");
sf_warning ("%s Total kernel time: %g s, per depth point: %g s",
ext, sf_timer_get_total_time (timer)/1000.0,
(sf_timer_get_total_time (timer)/(float)((size_t)nx*(size_t)ny*(size_t)nz))/1000.0);
}
sf_timer_close (timer);
for (ic = 0; ic < nc; ic++) {
sf_esc_point3_close (esc_points[ic]);
sf_esc_tracer3_close (esc_tracers[ic]);
}
free (esc_points);
free (esc_tracers);
if (traj) {
for (itr = 0; itr < nc*na*nb; itr++) {
free (tdata[itr].pnts[0]);
free (tdata[itr].pnts);
}
free (tdata);
}
sf_esc_slowness3_close (esc_slow);
free (e[0][0][0]);
free (e[0][0]);
free (e[0]);
free (e);
free (ext);
sf_fileclose (vspline);
if (traj)
sf_fileclose (traj);
return 0;
}
int main(int argc, char* argv[])
{
int nt, nx, it,ix;
float t,t0,dt, x,x0,dx, z;
float tmax,xmax,delx, dxdz,v0,alpha;
float** datr;
sf_file sag;
sf_init (argc, argv);
sag = sf_output("out");
if (!sf_getint ("nt",&nt)) nt = 200;
/* Number of samples in time */
if (!sf_getint ("nx",&nx)) nx = 200;
/* Number of samples in distance */
if (!sf_getfloat ("tmax",&tmax)) tmax = 4.;
/* Maximum time */
if (!sf_getfloat ("xmax",&xmax)) xmax = 4.;
/* Maximum distance */
if (!sf_getfloat ("delx",&delx)) delx = .5;
/* Increment in x */
if (!sf_getfloat ("dxdz",&dxdz)) dxdz = 1.;
/* Slope for the line of diffractors */
if (!sf_getfloat ("v0",&v0)) v0 = 1.5;
/* Initial velocity */
if (!sf_getfloat ("alpha",&alpha)) alpha = 0.;
/* Velocity gradient */
t0 = 0;
x0 = 0.;
dt = tmax / nt;
dx = xmax / nx;
sf_setformat(sag,"native_float");
sf_putint (sag,"n1",nt);
sf_putfloat (sag,"o1",t0);
sf_putfloat (sag,"d1",dt);
sf_putint (sag,"n2",nx);
sf_putfloat (sag,"o2",x0);
sf_putfloat (sag,"d2",dx);
sf_putstring (sag,"label1","Pseudo-depth (s)");
sf_putstring (sag,"label2","Lateral (km)");
datr = sf_floatalloc2(nt,nx);
for (ix=0; ix < nx; ix++) {
for (it=0; it < nt; it++) {
datr[ix][it] = 0.;
}
}
for (x = delx/2; x <= xmax; x+= delx) {
z = x / dxdz;
if( alpha != 0.) {
t = 2. * log( 1. + alpha * z / v0) / alpha;
} else {
t = 2. * z / v0;
}
it = 0.5 + t/dt;
ix = 0.5 + x/dx;
if(ix < nx && it < nt) datr[ix][it] += 1.;
}
sf_floatwrite (datr[0],nt*nx,sag);
exit (0);
}
int main(int argc, char* argv[])
{
int i, j, is, ip, dim, n[SF_MAX_DIM], ii[SF_MAX_DIM];
int nsp, **k=NULL, **l=NULL, n1, n2, i1, i2, kk, ll;
char key[7];
const char *label, *unit;
float f, *trace, *mag=NULL, **p=NULL, pp;
sf_file in, spike;
sf_init (argc,argv);
if (!sf_stdin()) { /* no input file in stdin */
in = NULL;
} else {
in = sf_input("in");
}
spike = sf_output("out");
if (NULL == in) {
sf_setformat(spike,"native_float");
} else if (SF_FLOAT != sf_gettype(in)) {
sf_error("Need float input");
}
/* dimensions */
for (i=0; i < SF_MAX_DIM; i++) {
snprintf(key,3,"n%d",i+1);
if (!sf_getint(key,n+i) &&
(NULL == in || !sf_histint(in,key,n+i))) break;
/*( n# size of #-th axis )*/
sf_putint(spike,key,n[i]);
}
if (0==i) sf_error("Need n1=");
dim=i;
/* basic parameters */
for (i=0; i < dim; i++) {
snprintf(key,3,"o%d",i+1);
if (!sf_getfloat(key,&f) &&
(NULL == in || !sf_histfloat(in,key,&f))) f=0.;
/*( o#=[0,0,...] origin on #-th axis )*/
sf_putfloat(spike,key,f);
snprintf(key,3,"d%d",i+1);
if (!sf_getfloat(key,&f) &&
(NULL == in || !sf_histfloat(in,key,&f))) f = (i==0)? 0.004: 0.1;
/*( d#=[0.004,0.1,0.1,...] sampling on #-th axis )*/
sf_putfloat(spike,key,f);
snprintf(key,7,"label%d",i+1);
if (NULL == (label = sf_getstring(key)) &&
(NULL == in || NULL == (label = sf_histstring(in,key))))
label = (i==0)? "Time":"Distance";
/*( label#=[Time,Distance,Distance,...] label on #-th axis )*/
if (*label != '\0' && (*label != ' ' || *(label+1) != '\0'))
sf_putstring(spike,key,label);
snprintf(key,6,"unit%d",i+1);
if (NULL == (unit = sf_getstring(key)) &&
(NULL == in || NULL == (unit = sf_histstring(in,key))))
unit = (i==0)? "s":"km";
/*( unit#=[s,km,km,...] unit on #-th axis )*/
if (*unit != '\0' && (*unit != ' ' || *(unit+1) != '\0'))
sf_putstring(spike,key,unit);
}
if (NULL != (label = sf_getstring("title")))
sf_putstring(spike,"title",label);
/* title for plots */
if (!sf_getint("nsp",&nsp)) nsp=1;
/* Number of spikes */
if (nsp >= 1) {
mag = sf_floatalloc (nsp);
k = sf_intalloc2 (nsp,dim);
l = sf_intalloc2 (nsp,dim);
p = sf_floatalloc2 (nsp,dim);
for (i=0; i < dim; i++) {
snprintf(key,3,"k%d",i+1);
if ( !sf_getints(key,k[i],nsp)) {
/*( k#=[0,...] spike starting position )*/
for (is=0; is < nsp; is++) {
k[i][is]=-1;
}
} else {
for (is=0; is < nsp; is++) {
if (k[i][is] > n[i])
sf_error("Invalid k%d[%d]=%d > n%d=%d",
i+1,is+1,k[i][is],i+1,n[i]);
k[i][is]--; /* C notation */
}
}
snprintf(key,3,"l%d",i+1);
if (!sf_getints(key,l[i],nsp)) {
/*( l#=[k1,k2,...] spike ending position )*/
for (is=0; is < nsp; is++) {
l[i][is]=k[i][is];
}
} else {
for (is=0; is < nsp; is++) {
if (l[i][is] > n[i])
sf_error("Invalid l%d[%d]=%d > n%d=%d",
i+1,is+1,l[i][is],i+1,n[i]);
l[i][is]--; /* C notation */
}
}
snprintf(key,3,"p%d",i+1);
if (!sf_getfloats(key,p[i],nsp)) {
/*( p#=[0,...] spike inclination (in samples) )*/
for (is=0; is < nsp; is++) {
p[i][is]=0.;
}
}
}
if (!sf_getfloats("mag",mag,nsp)) {
/* spike magnitudes */
for (is=0; is < nsp; is++) {
mag[is]=1.;
}
}
}
n1 = n[0];
n2 = sf_leftsize(spike,1);
trace = sf_floatalloc (n[0]);
for (i2=0; i2 < n2; i2++) { /* loop over traces */
sf_line2cart(dim-1, n+1, i2, ii+1);
/* zero trace */
for (i1=0; i1 < n1; i1++) trace[i1]=0.;
/* put spikes in it */
for (is=0; is < nsp; is++) { /* loop over spikes */
pp = 0.;
for (i=1; i < dim; i++) {
kk = k[i][is];
ll = l[i][is];
if ((kk < -1 && ll < -1) ||
(kk >= 0 && ll >= 0 &&
(kk > ii[i] || ll < ii[i]))) break;
pp += p[i][is]*(ii[i]-k[i][is]-1);
}
if (i < dim) continue; /* skip this spike */
/* linear interpolation */
ip = floorf(pp);
pp = 1.-(pp-ip);
kk = k[0][is];
ll = l[0][is];
if (kk >= 0) { /* one segment per trace */
kk = SF_MAX(kk+ip,0);
ll = SF_MIN(ll+ip,n1-1);
} else {
kk = SF_MAX(ip,0);
ll = SF_MIN(n1-1+ip,n1-1);
}
for (j=kk; j <= ll; j++) {
trace[j] += pp*mag[is];
if (j+1 < n1) trace[j+1] += (1.-pp)*mag[is];
}
}
sf_floatwrite(trace,n1,spike);
}
exit (0);
}
int main(int argc, char* argv[])
{
fint1 str, istr;
int i1,i2, n1,n2,n3, ix,iv,ih, ib, ie, nb, nx,nv,nh, nw, next;
float d1,o1,d2,o2, eps, w,x,k, v0,v2,v,v1,dv, dx, h0,dh,h, num, den, t, dw;
float *trace=NULL, *strace=NULL, ***stack=NULL, ***stack2=NULL, ***cont=NULL, **image=NULL;
sf_complex *ctrace=NULL, *ctrace0=NULL, shift;
char *time=NULL, *space=NULL, *unit=NULL;
size_t len;
static kiss_fftr_cfg forw, invs;
sf_file in=NULL, out=NULL;
bool sembl;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&nx)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&nh)) sf_error("No n3= in input");
if (!sf_getint("nb",&nb)) nb=2;
if (!sf_getfloat("eps",&eps)) eps=0.01;
if (!sf_getint("pad",&n2)) n2=n1;
if (!sf_getint("pad2",&n3)) n3=2*kiss_fft_next_fast_size((n2+1)/2);
nw = n3/2+1;
forw = kiss_fftr_alloc(n3,0,NULL,NULL);
invs = kiss_fftr_alloc(n3,1,NULL,NULL);
if (NULL == forw || NULL == invs)
sf_error("KISS FFT allocation error");
if (!sf_histfloat(in,"o1",&o1)) o1=0.;
o2 = o1*o1;
if(!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input");
d2 = o1+(n1-1)*d1;
d2 = (d2*d2 - o2)/(n2-1);
if (!sf_getint("nv",&nv)) sf_error("Need nv=");
if (!sf_getfloat("dv",&dv)) sf_error("Need dv=");
if (!sf_getfloat("v0",&v0) &&
!sf_histfloat(in,"v0",&v0)) sf_error("Need v0=");
if (!sf_getbool("semblance",&sembl)) sembl=true;
/* if y, compute semblance; if n, stack */
if(!sf_histfloat(in,"o3",&h0)) sf_error("No o2= in input");
if(!sf_histfloat(in,"d3",&dh)) sf_error("No d2= in input");
if(!sf_histfloat(in,"d2",&dx)) sf_error("No d3= in input");
sf_putfloat(out,"o3",v0+dv);
sf_putfloat(out,"d3",dv);
sf_putint(out,"n3",nv);
sf_putstring(out,"label3","Velocity");
if (NULL != (time = sf_histstring(in,"label1")) &&
NULL != (space = sf_histstring(in,"label2"))) {
len = strlen(time)+strlen(space)+2;
unit = sf_charalloc(len);
snprintf(unit,len,"%s/%s",space,time);
sf_putstring(out,"unit3",unit);
free(time);
free(space);
}
dx = 2*SF_PI/(2*kiss_fft_next_fast_size(nx-1)*dx);
dw = 16*SF_PI/(d2*n3); /* 2pi * 8 */
stack = sf_floatalloc3(n1,nx,nv);
stack2 = sf_floatalloc3(n1,nx,nv);
cont = sf_floatalloc3(n1,nx,nv);
image = sf_floatalloc2(n1,nx);
trace = sf_floatalloc(n1);
strace = sf_floatalloc(n3);
ctrace = sf_complexalloc(nw);
ctrace0 = sf_complexalloc(nw);
if (!sf_getint("extend",&next)) next=4;
/* trace extension */
str = fint1_init(next,n1,0);
istr = fint1_init(next,n2,0);
for (i1=0; i1 < n1*nx*nv; i1++) {
stack[0][0][i1] = 0.;
stack2[0][0][i1] = 0.;
}
sf_cosft_init(nx);
for (ih=0; ih < nh; ih++) {
sf_warning("offset %d of %d;",ih+1,nh);
h = h0 + ih*dh;
h *= h * 0.5;
sf_floatread(image[0],n1*nx,in);
for (i1=0; i1 < n1; i1++) {
sf_cosft_frw(image[0],i1,n1);
}
for (ix=0; ix < nx; ix++) {
x = ix*dx;
x *= x;
k = x * 0.5;
fint1_set(str,image[ix]);
for (i2=0; i2 < n2; i2++) {
t = o2+i2*d2;
t = sqrtf(t);
t = (t-o1)/d1;
i1 = t;
if (i1 >= 0 && i1 < n1) {
strace[i2] = fint1_apply(str,i1,t-i1,false);
} else {
strace[i2] = 0.;
}
}
for (i2=n2; i2 < n3; i2++) {
strace[i2] = 0.;
}
kiss_fftr(forw,strace, (kiss_fft_cpx *) ctrace0);
for (iv=0; iv < nv; iv++) {
v = v0 + (iv+1)* dv;
v1 = h * (1./(v*v) - 1./(v0*v0));
v2 = k * ((v0*v0) - (v*v));
ctrace[0]=sf_cmplx(0.,0.); /* dc */
for (i2=1; i2 < nw; i2++) {
w = i2*dw;
w = v2/w+(v1-0.125*o2)*w;
shift = sf_cmplx(cosf(w),sinf(w));
#ifdef SF_HAS_COMPLEX_H
ctrace[i2] = ctrace0[i2] * shift;
#else
ctrace[i2] = sf_cmul(ctrace0[i2],shift);
#endif
} /* w */
kiss_fftri(invs,(const kiss_fft_cpx *) ctrace, strace);
fint1_set(istr,strace);
for (i1=0; i1 < n1; i1++) {
t = o1+i1*d1;
t = t*t;
t = (t-o2)/d2;
i2 = t;
if (i2 >= 0 && i2 < n2) {
cont[iv][ix][i1] = fint1_apply(istr,i2,t-i2,false);
} else {
cont[iv][ix][i1] = 0.;
}
}
} /* v */
} /* x */
for (iv=0; iv < nv; iv++) {
for (i1=0; i1 < n1; i1++) {
sf_cosft_inv(cont[0][0],i1+iv*nx*n1,n1);
}
}
for (iv=0; iv < nv; iv++) {
for (ix=0; ix < nx; ix++) {
for (i1=0; i1 < n1; i1++) {
t = cont[iv][ix][i1];
stack[iv][ix][i1] += t;
stack2[iv][ix][i1] += t*t;
} /* i1 */
} /* x */
} /* v */
} /* h */
sf_warning(".");
for (iv=0; iv < nv; iv++) {
for (ix=0; ix < nx; ix++) {
for (i1=0; i1 < n1; i1++) {
ib = i1-nb > 0? i1-nb: 0;
ie = i1+nb+1 < n1? i1+nb+1: n1;
num = 0.;
den = 0.;
if (sembl) {
for (i2=ib; i2 < ie; i2++) {
t = stack[iv][ix][i2];
num += t*t;
den += stack2[iv][ix][i2];
}
den *= nh;
trace[i1] = den > 0.? num/den: 0.;
} else {
for (i2=ib; i2 < ie; i2++) {
t = stack[iv][ix][i2];
num += t;
}
den = nh;
trace[i1] = num/(den+ FLT_EPSILON);
}
}
sf_floatwrite (trace,n1,out);
}
}
exit(0);
}
int main(int argc, char* argv[])
{
bool verb;
int n[SF_MAX_DIM], n0[SF_MAX_DIM], rect[SF_MAX_DIM];
int a[SF_MAX_DIM], center[SF_MAX_DIM], gap[SF_MAX_DIM];
int ndim, dim, n123, n123s, i, ia, ns, i1, niter, na, i4, n4, *kk;
float *d, *f, *dd;
double mean;
char *lagfile, key[6];
sf_filter aa;
sf_file in, filt, lag;
sf_init(argc,argv);
in = sf_input("in");
filt = sf_output("out");
if (NULL == (lagfile = sf_getstring("lag"))) sf_error("Need lag=");
/* output file for filter lags */
lag = sf_output(lagfile);
sf_settype(lag,SF_INT);
sf_putstring(filt,"lag",lagfile);
ndim = sf_filedims(in,n);
if (!sf_getint("dim",&dim)) dim=ndim; /* number of dimensions */
n4 = sf_leftsize(in,dim);
sf_putints (lag,"n",n,dim);
if (!sf_getints("a",a,dim)) sf_error("Need a=");
if (!sf_getints("center",center,dim)) {
for (i=0; i < dim; i++) {
center[i] = (i+1 < dim && a[i+1] > 1)? a[i]/2: 0;
}
}
if (!sf_getint("na",&na)) na=0;
/* filter size */
if (0 == na) {
if (!sf_getints("gap",gap,dim)) {
for (i=0; i < dim; i++) {
gap[i] = 0;
}
}
aa = createhelix(dim, n, center, gap, a); /* allocate PEF */
for (i=0; i < dim; i++) {
n0[i] = n[i];
}
} else {
aa = sf_allocatehelix (na);
if (!sf_getints ("lags", aa->lag, na)) sf_error("Need lags=");
if (!sf_getints ("n", n0, dim)) {
for (i=0; i < dim; i++) {
n0[i] = n[i];
}
}
}
n123 = 1;
for (i=0; i < dim; i++) {
n123 *= n[i];
snprintf(key,6,"rect%d",i+1);
if (!sf_getint(key,rect+i)) rect[i]=1;
}
dd = sf_floatalloc(n123);
kk = sf_intalloc(n123);
for (i1=0; i1 < n123; i1++) {
kk[i1] = 1;
}
bound (dim, n0, n, a, aa);
find_mask(n123, kk, aa);
na = aa->nh;
snprintf(key,3,"n%d",dim+1);
sf_putint(filt,key,na);
sf_shiftdim(in, filt, dim+1);
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getbool("verb",&verb)) verb = true;
/* verbosity flag */
n123s = n123*na;
d = sf_floatalloc(n123s);
f = sf_floatalloc(n123s);
sf_multidivn_init(na, dim, n123, n, rect, d, NULL, verb);
for (i4=0; i4 < n4; i4++) {
sf_floatread(dd,n123,in);
/* apply shifts: dd -> d */
mean = 0.;
for (i=ia=0; ia < na; ia++) {
ns = aa->lag[ia];
for (i1=0; i1 < n123; i1++,i++) {
if (i1 < ns) {
d[i] = 0.0f;
} else {
d[i] = dd[i1-ns];
mean += d[i]*d[i];
}
}
}
if (mean == 0.) {
sf_floatwrite(d,n123s,filt);
continue;
}
mean = sqrt (n123s/mean);
/* -> apply mask */
for(i=0; i < n123s; i++) {
d[i] *= mean;
}
for(i1=0; i1 < n123; i1++) {
dd[i1] *= mean;
}
sf_multidivn (dd,f,niter);
sf_floatwrite(f,n123s,filt);
}
exit(0);
}
int main(int argc, char* argv[])
{
int n12, n1, n2, n3, i3, sw, niter, liter;
bool hd, ps, verb;
float *data, *modl, *vrms, *error=NULL;
float o1,d1,o2,d2,eps;
char *errfile;
sf_file in, out, vel, err=NULL;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n3 = sf_leftsize(in,2);
if (!sf_getbool("hd",&hd)) hd=true;
/* if y, apply half-derivative filter */
if (!sf_getbool("ps",&ps)) ps=true;
/* if y, apply pseudo-unitary weighting */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
if (!sf_getint("sw",&sw)) sw=0;
/* if > 0, select a branch of the antialiasing operation */
if (!sf_getint("niter",&niter)) niter=5;
/* number of non-linear iterations, when niter=1, it's linear */
if (!sf_getint("liter",&liter)) liter=5;
/* number of linear iterations */
if (!sf_getfloat("eps",&eps)) eps=0.;
/* regularization parameters */
if (!sf_histfloat(in,"o1",&o1)) sf_error("No o1= in input");
if (!sf_histfloat(in,"o2",&o2)) sf_error("No o2= in input");
if (!sf_histfloat(in,"d1",&d1)) sf_error("No d1= in input");
if (!sf_histfloat(in,"d2",&d2)) sf_error("No d2= in input");
vrms = sf_floatalloc(n1);
vel = sf_input("velocity");
sf_floatread(vrms,n1,vel);
sf_fileclose(vel);
n12 = n1*n2;
data = sf_floatalloc(n12);
modl = sf_floatalloc(n12);
if (niter > 0) {
errfile = sf_getstring("err");
/* output file for error */
if (NULL != errfile) {
err = sf_output(errfile);
sf_putint(err,"n1",liter);
sf_putfloat(err,"d1",1);
sf_putfloat(err,"o1",1);
sf_putstring(err,"label1","Iteration Number");
sf_putstring(err,"label2","Relative Squared Error");
sf_putint(err,"n2",1);
}
error = sf_floatalloc(liter);
}
kirchnew_init (vrms, o1, d1, d2, n1, n2, sw, ps, hd);
for (i3=0; i3 < n3; i3++) {
sf_floatread (data,n12,in);
inverts(kirchnew_lop,niter,niter,liter,n12,n12,modl,data,error,verb,eps);
sf_floatwrite (modl,n12,out);
if (NULL != err) sf_floatwrite(error,liter,err);
}
sf_warning(".");
exit(0);
}
int main(int argc, char* argv[])
{
/*survey parameters*/
int nx, nz;
float dx, dz;
int n_srcs;
int *spx, *spz;
int gpz, gpx, gpl;
int gpz_v, gpx_v, gpl_v;
int snap;
/*fft related*/
bool cmplx;
int pad1;
/*absorbing boundary*/
bool abc;
int nbt, nbb, nbl, nbr;
float ct,cb,cl,cr;
/*source parameters*/
int src; /*source type*/
int nt,ntsnap;
float dt,*f0,*t0,*A;
/*misc*/
bool verb, ps, mig;
float vref;
pspar par;
int nx1, nz1; /*domain of interest*/
int it;
float *vel,**dat,**dat_v,**wvfld,*img; /*velocity profile*/
sf_file Fi,Fo,Fd,Fd_v,snaps; /* I/O files */
sf_axis az,ax; /* cube axes */
sf_init(argc,argv);
if (!sf_getint("snap",&snap)) snap=0; /* interval for snapshots */
if (!sf_getbool("cmplx",&cmplx)) cmplx=true; /* use complex fft */
if (!sf_getint("pad1",&pad1)) pad1=1; /* padding factor on the first axis */
if(!sf_getbool("abc",&abc)) abc=false; /* absorbing flag */
if (abc) {
if(!sf_getint("nbt",&nbt)) sf_error("Need nbt!");
if(!sf_getint("nbb",&nbb)) nbb = nbt;
if(!sf_getint("nbl",&nbl)) nbl = nbt;
if(!sf_getint("nbr",&nbr)) nbr = nbt;
if(!sf_getfloat("ct",&ct)) sf_error("Need ct!");
if(!sf_getfloat("cb",&cb)) cb = ct;
if(!sf_getfloat("cl",&cl)) cl = ct;
if(!sf_getfloat("cr",&cr)) cr = ct;
} else {
nbt = 0; nbb = 0; nbl = 0; nbr = 0;
ct = 0; cb = 0; cl = 0; cr = 0;
}
if (!sf_getbool("verb",&verb)) verb=false; /* verbosity */
if (!sf_getbool("ps",&ps)) ps=false; /* use pseudo-spectral */
if (ps) sf_warning("Using pseudo-spectral...");
else sf_warning("Using pseudo-analytical...");
if (!sf_getbool("mig",&mig)) mig=false; /* use pseudo-spectral */
if (mig) sf_warning("Time-reversal propagation");
else sf_warning("Forward modeling");
if (!sf_getfloat("vref",&vref)) vref=1500; /* reference velocity (default using water) */
/* setup I/O files */
Fi = sf_input ("in");
Fo = sf_output("out");
if (mig) {
gpl = -1;
gpl_v = -1;
if (NULL==sf_getstring("dat") && NULL==sf_getstring("dat_v"))
sf_error("Need Data!");
if (NULL!=sf_getstring("dat")) {
Fd = sf_input("dat");
sf_histint(Fd,"n1",&nt);
sf_histfloat(Fd,"d1",&dt);
sf_histint(Fd,"n2",&gpl);
} else Fd = NULL;
if (NULL!=sf_getstring("dat_v")) {
Fd_v = sf_input("dat_v");
sf_histint(Fd_v,"n1",&nt);
sf_histfloat(Fd_v,"d1",&dt);
sf_histint(Fd_v,"n2",&gpl_v);
} else Fd_v = NULL;
src = -1; n_srcs = -1;
spx = NULL; spz = NULL;
f0 = NULL; t0 = NULL; A = NULL;
} else {
Fd = NULL;
if (!sf_getint("nt",&nt)) sf_error("Need nt!");
if (!sf_getfloat("dt",&dt)) sf_error("Need dt!");
if (!sf_getint("gpl",&gpl)) gpl = -1; /* geophone length */
if (!sf_getint("gpl_v",&gpl_v)) gpl_v = -1; /* geophone height */
if (!sf_getint("src",&src)) src=0; /* source type */
if (!sf_getint("n_srcs",&n_srcs)) n_srcs=1; /* source type */
spx = sf_intalloc(n_srcs);
spz = sf_intalloc(n_srcs);
f0 = sf_floatalloc(n_srcs);
t0 = sf_floatalloc(n_srcs);
A = sf_floatalloc(n_srcs);
if (!sf_getints("spx",spx,n_srcs)) sf_error("Need spx!"); /* shot position x */
if (!sf_getints("spz",spz,n_srcs)) sf_error("Need spz!"); /* shot position z */
if (!sf_getfloats("f0",f0,n_srcs)) sf_error("Need f0! (e.g. 30Hz)"); /* wavelet peak freq */
if (!sf_getfloats("t0",t0,n_srcs)) sf_error("Need t0! (e.g. 0.04s)"); /* wavelet time lag */
if (!sf_getfloats("A",A,n_srcs)) sf_error("Need A! (e.g. 1)"); /* wavelet amplitude */
}
if (!sf_getint("gpx",&gpx)) gpx = -1; /* geophone position x */
if (!sf_getint("gpz",&gpz)) gpz = -1; /* geophone position z */
if (!sf_getint("gpx_v",&gpx_v)) gpx_v = -1; /* geophone position x */
if (!sf_getint("gpz_v",&gpz_v)) gpz_v = -1; /* geophone position z */
if (SF_FLOAT != sf_gettype(Fi)) sf_error("Need float input");
/* Read/Write axes */
az = sf_iaxa(Fi,1); nz = sf_n(az); dz = sf_d(az);
ax = sf_iaxa(Fi,2); nx = sf_n(ax); dx = sf_d(ax);
nz1 = nz-nbt-nbb;
nx1 = nx-nbl-nbr;
if (gpx==-1) gpx = nbl;
if (gpz==-1) gpz = nbt;
if (gpl==-1) gpl = nx1;
if (gpx_v==-1) gpx_v = nbl;
if (gpz_v==-1) gpz_v = nbt;
if (gpl_v==-1) gpl_v = nz1;
ntsnap=0;
if (snap)
for (it=0;it<nt;it++)
if (it%snap==0) ntsnap++;
if (mig) { /*output final wavefield*/
sf_setn(az,nz1);
sf_setn(ax,nx1);
sf_oaxa(Fo,az,1);
sf_oaxa(Fo,ax,2);
sf_settype(Fo,SF_FLOAT);
} else { /*output data*/
sf_setn(ax,gpl);
/*output horizontal data is mandatory*/
sf_putint(Fo,"n1",nt);
sf_putfloat(Fo,"d1",dt);
sf_putfloat(Fo,"o1",0.);
sf_putstring(Fo,"label1","Time");
sf_putstring(Fo,"unit1","s");
sf_oaxa(Fo,ax,2);
sf_settype(Fo,SF_FLOAT);
/*output vertical data is optional*/
if (NULL!=sf_getstring("dat_v")) {
Fd_v = sf_output("dat_v");
sf_setn(az,gpl_v);
sf_putint(Fd_v,"n1",nt);
sf_putfloat(Fd_v,"d1",dt);
sf_putfloat(Fd_v,"o1",0.);
sf_putstring(Fd_v,"label1","Time");
sf_putstring(Fd_v,"unit1","s");
sf_oaxa(Fd_v,az,2);
sf_settype(Fd_v,SF_FLOAT);
} else Fd_v = NULL;
}
if (snap > 0) {
snaps = sf_output("snaps");
/* (optional) snapshot file */
sf_setn(az,nz1);
sf_setn(ax,nx1);
sf_oaxa(snaps,az,1);
sf_oaxa(snaps,ax,2);
sf_putint(snaps,"n3",ntsnap);
sf_putfloat(snaps,"d3",dt*snap);
sf_putfloat(snaps,"o3",0.);
sf_putstring(snaps,"label3","Time");
sf_putstring(snaps,"unit3","s");
} else snaps = NULL;
par = (pspar) sf_alloc(1,sizeof(*par));
vel = sf_floatalloc(nz*nx);
if (mig && NULL==Fd) dat = NULL;
else dat = sf_floatalloc2(nt,gpl);
if (NULL!=Fd_v) dat_v = sf_floatalloc2(nt,gpl_v);
else dat_v = NULL;
if (mig) img = sf_floatalloc(nz1*nx1);
else img = NULL;
if (snap>0) wvfld = sf_floatalloc2(nx1*nz1,ntsnap);
else wvfld = NULL;
sf_floatread(vel,nz*nx,Fi);
if (mig) {
if (NULL!=Fd) sf_floatread(dat[0],gpl*nt,Fd);
if (NULL!=Fd_v) sf_floatread(dat_v[0],gpl_v*nt,Fd_v);
}
/*passing the parameters*/
par->nx = nx;
par->nz = nz;
par->dx = dx;
par->dz = dz;
par->n_srcs= n_srcs;
par->spx = spx;
par->spz = spz;
par->gpz = gpz;
par->gpx = gpx;
par->gpl = gpl;
par->gpz_v = gpz_v;
par->gpx_v = gpx_v;
par->gpl_v = gpl_v;
par->snap = snap;
par->cmplx = cmplx;
par->pad1 = pad1;
par->abc = abc;
par->nbt = nbt;
par->nbb = nbb;
par->nbl = nbl;
par->nbr = nbr;
par->ct = ct;
par->cb = cb;
par->cl = cl;
par->cr = cr;
par->src = src;
par->nt = nt;
par->dt = dt;
par->f0 = f0;
par->t0 = t0;
par->A = A;
par->verb = verb;
par->ps = ps;
par->vref = vref;
/*do the work*/
psp(wvfld, dat, dat_v, img, vel, par, mig);
if (mig) {
sf_floatwrite(img,nz1*nx1,Fo);
} else {
sf_floatwrite(dat[0],gpl*nt,Fo);
if (NULL!=Fd_v)
sf_floatwrite(dat_v[0],gpl_v*nt,Fd_v);
}
if (snap>0)
sf_floatwrite(wvfld[0],nz1*nx1*ntsnap,snaps);
exit (0);
}
int main(int argc, char* argv[])
{
int n1, n2, n3, gainstep, panel, it, nreserve, i1, i2, i3, j, orient;
float o1, o2, o3, d1, d2, d3, gpow, clip, pclip, phalf, bias=0., minmax[2];
float pbias, gain=0., x1, y1, x2, y2, **data=NULL, f, barmin, barmax, dat;
bool transp, yreverse, xreverse, allpos, polarity, symcp, verb;
bool eclip=false, egpow=false, barreverse, mean=false;
bool scalebar, nomin=true, nomax=true, framenum, sfbyte, sfbar, charin;
char *gainpanel, *color, *barfile;
unsigned char tbl[TSIZE+1], **buf, tmp, *barbuf[1];
enum {GAIN_EACH=-3,GAIN_ALL=-2,NO_GAIN=-1};
off_t pos;
sf_file in, out=NULL, bar=NULL;
sf_init(argc,argv);
in = sf_input("in");
sfbyte = (bool) (NULL != strstr (sf_getprog(),"byte"));
sfbar = (bool) (NULL != strstr (sf_getprog(),"bar"));
if (sfbyte) {
out = sf_output("out");
sf_settype(out,SF_UCHAR);
} else if (sfbar) {
bar = sf_output("out");
sf_settype(bar,SF_UCHAR);
} else {
vp_init();
}
charin = (bool) (SF_UCHAR == sf_gettype(in));
if (charin && sfbyte) sf_error("Cannot input uchar to byte");
if (!charin && SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) n2=1;
n3 = sf_leftsize(in,2);
if (!sf_histfloat(in,"o1",&o1)) o1=0.;
if (!sf_histfloat(in,"o2",&o2)) o2=0.;
if (!sf_histfloat(in,"o3",&o3)) o3=0.;
if (!sf_histfloat(in,"d1",&d1)) d1=1.;
if (!sf_histfloat(in,"d2",&d2)) d2=1.;
if (!sf_histfloat(in,"d3",&d3)) d3=1.;
if (!sf_getbool("transp",&transp)) transp=true;
/* if y, transpose the display axes */
if (!sf_getbool("yreverse",&yreverse)) yreverse=true;
/* if y, reverse the vertical axis */
if (!sf_getbool("xreverse",&xreverse)) xreverse=false;
/* if y, reverse the horizontal axis */
if (transp) {
orient = 3;
} else {
orient = (xreverse==yreverse)? 0:2;
}
if (!charin) {
panel = NO_GAIN; /* no need for gain */
phalf=85.;
egpow = false;
if (!sf_getfloat("gpow",&gpow)) {
gpow=1.;
/*( gpow=1 raise data to gpow power for display )*/
} else if (gpow <= 0.) {
gpow=0.;
egpow = true;
sf_getfloat("phalf",&phalf);
/* percentage for estimating gpow */
if (phalf <=0. || phalf > 100.)
sf_error("phalf=%g should be > 0 and <= 100",phalf);
panel = 0;
}
pclip=99.;
eclip = (bool) (!sf_getfloat("clip",&clip));
/* data clip */
if (eclip) {
clip = 0.;
sf_getfloat("pclip",&pclip);
/* data clip percentile (default is 99) */
if (pclip <=0. || pclip > 100.)
sf_error("pclip=%g should be > 0 and <= 100",pclip);
panel = 0;
} else if (clip <= 0.) {
sf_warning("clip=%g <= 0",clip);
clip = FLT_EPSILON;
}
if (0==panel) {
if (!sf_getint("gainstep",&gainstep)) gainstep=0.5+n1/256.;
/* subsampling for gpow and clip estimation */
if (gainstep <= 0) gainstep=1;
gainpanel = sf_getstring("gainpanel");
/* gain reference: 'a' for all, 'e' for each, or number */
if (NULL != gainpanel) {
switch (gainpanel[0]) {
case 'a':
panel=GAIN_ALL;
break;
case 'e':
panel=GAIN_EACH;
break;
default:
if (0 ==sscanf(gainpanel,"%d",&panel) ||
panel < 1 || panel > n3)
sf_error("gainpanel= should be all,"
" each, or a number"
" between 1 and %d",n3);
panel--;
break;
}
free (gainpanel);
}
sf_unpipe(in,sf_filesize(in)*sizeof(float));
}
if (!sf_getbool("allpos",&allpos)) allpos=false;
/* if y, assume positive data */
if (!sf_getbool("mean",&mean)) mean=false;
/* if y, bias on the mean value */
if (!sf_getfloat("bias",&pbias)) pbias=0.;
/* value mapped to the center of the color table */
if (!sf_getbool("polarity",&polarity)) polarity=false;
/* if y, reverse polarity (white is high by default) */
if (!sf_getbool("symcp",&symcp)) symcp=false;
/* if y, assume symmetric color palette of 255 colors */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
} /* if !charin */
barfile = sf_getstring("bar");
/* file for scalebar data */
if (sfbyte) {
scalebar = (bool) (NULL != barfile);
if (scalebar) sf_putstring(out,"bar",barfile);
} else if (sfbar) {
scalebar = true;
} else {
if (!sf_getbool ("wantscalebar",&scalebar) &&
!sf_getbool ("scalebar",&scalebar)) scalebar = false;
/* if y, draw scalebar */
}
if (scalebar) {
nomin = (bool) (!sf_getfloat("minval",&barmin));
/* minimum value for scalebar (default is the data minimum) */
nomax = (bool) (!sf_getfloat("maxval",&barmax));
/* maximum value for scalebar (default is the data maximum) */
barbuf[0] = sf_ucharalloc(VP_BSIZE);
if (!sf_getbool("barreverse",&barreverse)) barreverse=false;
/* if y, go from small to large on the bar scale */
if (sfbyte || sfbar) {
if (sfbyte) {
bar = sf_output("bar");
sf_settype(bar,SF_UCHAR);
}
sf_putint(bar,"n1",VP_BSIZE+2*sizeof(float));
sf_putint(bar,"n2",1);
sf_putint(bar,"n3",n3);
if (!nomin) sf_putfloat(bar,"minval",barmin);
if (!nomax) sf_putfloat(bar,"maxval",barmax);
} else if (charin) {
if (NULL == barfile) {
barfile=sf_histstring(in,"bar");
if (NULL == barfile) sf_error("Need bar=");
}
bar = sf_input(barfile);
if (SF_UCHAR != sf_gettype(bar)) sf_error("Need uchar in bar");
if (nomin) nomin = (bool) (!sf_histfloat(bar,"minval",&barmin));
if (nomax) nomax = (bool) (!sf_histfloat(bar,"maxval",&barmax));
}
}
if (!sf_getbool("wantframenum",&framenum)) framenum = (bool) (n3 > 1);
/* if y, display third axis position in the corner */
x1 = o1-0.5*d1;
x2 = o1+(n1-1)*d1+0.5*d1;
y1 = o2-0.5*d2;
y2 = o2+(n2-1)*d2+0.5*d2;
if (!sfbyte && !sfbar) {
vp_stdplot_init (x1, x2, y1, y2, transp, false, yreverse, false);
vp_frame_init(in,"tlb",false);
/* if (scalebar && !nomin && !nomax)
vp_barframe_init (in,barmin,barmax); */
}
if (transp) {
f=x1; x1=y1; y1=f;
f=x2; x2=y2; y2=f;
}
if (yreverse) {
f=y1; y1=y2; y2=f;
}
if (xreverse) {
f=x1; x1=x2; x2=f;
}
buf = sf_ucharalloc2(n1,n2);
if (!charin) {
data = sf_floatalloc2(n1,n2);
if (GAIN_ALL==panel || panel >= 0) {
pos = sf_tell(in);
if (panel > 0) sf_seek(in,
pos+panel*n1*n2*sizeof(float),
SEEK_SET);
vp_gainpar (in,data,n1,n2,gainstep,
pclip,phalf,&clip,&gpow,mean,&pbias,
n3,panel,panel);
if (verb) sf_warning("panel=%d bias=%g clip=%g gpow=%g",
panel,pbias,clip,gpow);
if (sfbyte) sf_putfloat(out,"clip",clip);
sf_seek(in,pos,SEEK_SET); /* rewind */
}
}
if (!sfbyte && !sfbar) {
/* initialize color table */
if (NULL == (color = sf_getstring("color"))) color="i";
/* color scheme (default is i) */
if (!sf_getint ("nreserve",&nreserve)) nreserve = 8;
/* reserved colors */
vp_rascoltab (nreserve, color);
}
for (i3=0; i3 < n3; i3++) {
if (!charin) {
if (GAIN_EACH == panel) {
if (eclip) clip=0.;
if (egpow) gpow=0.;
vp_gainpar (in,data,n1,n2,gainstep,
pclip,phalf,&clip,&gpow,
mean,&pbias,n3,0,n3);
if (verb) sf_warning("bias=%g clip=%g gpow=%g",pbias,clip,gpow);
} else {
sf_floatread(data[0],n1*n2,in);
}
if (1 == panel || GAIN_EACH == panel || 0==i3) {
/* initialize the conversion table */
if(!allpos) { /* negative and positive values */
for (it=1; it<=TSIZE/2; it++) {
if (symcp) {
tbl[TSIZE-it] = (gpow != 1.)?
254*(pow(((TSIZE-2.0*it)/TSIZE),gpow)+1.)/2.+1.:
254*( ((TSIZE-2.0*it)/TSIZE) +1.)/2.+1.;
tbl[it] = 255 - tbl[TSIZE-it] + 1.0;
} else {
tbl[TSIZE-it] = (gpow != 1.)?
252*(pow(((TSIZE-2.0*it)/TSIZE),gpow)+1.)/2.+3.:
252*( ((TSIZE-2.0*it)/TSIZE) +1.)/2.+3.;
tbl[it] = 255 - tbl[TSIZE-it] + 2.0;
}
}
bias = TSIZE/2.;
gain = TSIZE/(2.*clip);
} else { /* all positive */
if (symcp) {
for (it=1; it < TSIZE ; it++) {
tbl[it] = 255*((it-1.0)/TSIZE) + 1.0;
}
} else {
for (it=1; it < TSIZE ; it++) {
tbl[it] = 256*((it-1.0)/TSIZE);
}
}
bias = 0.;
gain = TSIZE/clip;
}
tbl[0] = tbl[1];
tbl[TSIZE] = tbl[TSIZE-1];
if (polarity) { /* switch polarity */
for (it=0; it<=TSIZE; it++) {
tbl[it]=255-tbl[it];
}
}
}
/* convert to bytes */
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
j = (data[i2][i1]-pbias)*gain + bias;
if (j < 0) j=0;
else if (j > TSIZE) j=TSIZE;
buf[i2][i1] = tbl[j];
}
}
} else {
sf_ucharread(buf[0],n1*n2,in);
}
if (!sfbyte && !sfbar) {
if (yreverse) {
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1/2; i1++) {
tmp = buf[i2][i1];
buf[i2][i1] = buf[i2][n1-1-i1];
buf[i2][n1-1-i1] = tmp;
}
}
}
if ((xreverse && transp) || (!xreverse && !transp)) {
for (i2=0; i2 < n2/2; i2++) {
for (i1=0; i1 < n1; i1++) {
tmp = buf[i2][i1];
buf[i2][i1] = buf[n2-1-i2][i1];
buf[n2-1-i2][i1] = tmp;
}
}
}
if (i3 > 0) vp_erase ();
if (framenum) vp_framenum(o3+i3*d3);
vp_frame();
vp_uraster (buf, false, 256, n1, n2,
x1, y1, x2, y2, orient);
vp_simpleframe();
}
if (scalebar) {
if (!charin) {
if (nomin) barmin = data[0][0];
if (nomax) barmax = data[0][0];
if (nomin || nomax) {
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
dat = data[i2][i1];
if (nomin && barmin > dat) barmin = dat;
if (nomax && barmax < dat) barmax = dat;
}
}
}
for (it=0; it < VP_BSIZE; it++) {
if (barreverse) {
dat = (barmin*it + barmax*(VP_BSIZE-1-it))/(VP_BSIZE-1);
} else {
dat = (barmax*it + barmin*(VP_BSIZE-1-it))/(VP_BSIZE-1);
}
j = (dat-pbias)*gain + bias;
if (j < 0) j=0;
else if (j > TSIZE) j=TSIZE;
barbuf[0][it] = tbl[j];
}
} else {
sf_floatread(minmax,2,bar);
sf_ucharread(barbuf[0],VP_BSIZE,bar);
if (nomin) barmin=minmax[0];
if (nomax) barmax=minmax[1];
}
if (sfbyte || sfbar) {
sf_floatwrite(&barmin,1,bar);
sf_floatwrite(&barmax,1,bar);
sf_ucharwrite(barbuf[0],VP_BSIZE,bar);
} else {
if (barreverse) {
vp_barframe_init (in,barmax,barmin);
} else {
vp_barframe_init (in,barmin,barmax);
}
vp_barraster(VP_BSIZE, barbuf);
}
} /* if scalebar */
if (sfbyte) {
sf_ucharwrite(buf[0],n1*n2,out);
} else if (!sfbar) {
vp_purge();
}
} /* i3 loop */
exit (0);
}
int main(int argc, char* argv[])
{
int nx, nz, na, nb, i, j;
float fx, fz, dx, dz, da, db;
sf_init(argc,argv);
sf_file Fo1, Fo2, Fo3, Fo4, Fo5, Fo6;
Fo1 = sf_input("in"); // wavefront1
Fo2 = sf_input("wave2"); // wavefront2
Fo3 = sf_output("out"); // wavetrans1
Fo4 = sf_output("wavetrans2"); // wavetrans2
Fo5 = sf_output("amp1"); // amplitue1
Fo6 = sf_output("amp2"); // amplitue2
float **snap1, **snap2;
float **sn1, **sn2;
float *amp1, *amp2;
float amax, amax1, amax2;
/* Read/Write axes */
sf_axis az, ax;
az = sf_iaxa(Fo1,1); nz = sf_n(az); dz = sf_d(az)*1000;
ax = sf_iaxa(Fo1,2); nx = sf_n(ax); dx = sf_d(ax)*1000;
fx=sf_o(ax);
fz=sf_o(az);
sf_warning("nx= %d nz= %d",nx,nz);
sf_warning("dx= %f dz= %f",dx,dz);
na = 720;
da = 180.0/na;
nb = nx*2;
db = dx/2.0;
sf_warning("da= %f db= %f",da,db);
sf_putint(Fo3,"n1",nb);
sf_putint(Fo3,"n2",na);
sf_putfloat(Fo3,"d1",db);
sf_putfloat(Fo3,"o1",0.0f);
sf_putfloat(Fo3,"d2",da);
sf_putfloat(Fo3,"o2",-90.0f);
sf_putint(Fo4,"n1",nb);
sf_putint(Fo4,"n2",na);
sf_putfloat(Fo4,"d1",db);
sf_putfloat(Fo4,"o1",0.0f);
sf_putfloat(Fo4,"d2",da);
sf_putfloat(Fo4,"o2",-90.0f);
sf_putint(Fo5,"n2",1);
sf_putint(Fo5,"n1",na);
sf_putfloat(Fo5,"d1",da);
sf_putfloat(Fo5,"o1",-90.0f);
sf_putstring(Fo5,"label1","Phase angle");
sf_putstring(Fo5,"unit1","Degree");
sf_putint(Fo6,"n2",1);
sf_putint(Fo6,"n1",na);
sf_putfloat(Fo6,"d1",da);
sf_putfloat(Fo6,"o1",-90.0f);
sf_putstring(Fo6,"label1","Phase angle");
sf_putstring(Fo6,"unit1","Degree");
snap1=sf_floatalloc2(nz, nx);
snap2=sf_floatalloc2(nz, nx);
sn1=sf_floatalloc2(nb, na);
sn2=sf_floatalloc2(nb, na);
amp1=sf_floatalloc(na);
amp2=sf_floatalloc(na);
for(i=0;i<nx;i++){
sf_floatread(snap1[i], nz, Fo1);
sf_floatread(snap2[i], nz, Fo2);
}
for(i=0;i<na;i++){
amp1[i]=0.0;
amp2[i]=0.0;
for(j=0;j<nb;j++){
sn1[i][j]=0.0;
sn2[i][j]=0.0;
}
}
for(i=0;i<na;i++){
float a=i*da;
a *= SF_PI/180.0;
for(j=0;j<nb;j++){
float b=j*db;
float x=(nx-1)*dx*0.5-b*cos(a);
float z=(nz-1)*dz*0.5+b*sin(a);
int ix, iz;
ix=x/dx;
iz=z/dz;
if(ix>=0&&ix<nx&&iz>=nz/2&&iz<nz){
//sf_warning("i=%d a=%f j=%d b=%f x=%f z=%f ix=%d iz=%d",i,a,j,b,x,z,ix,iz);
sn1[i][j]=snap1[ix][iz];
sn2[i][j]=snap2[ix][iz];
}
}
sf_floatwrite(sn1[i], nb, Fo3);
sf_floatwrite(sn2[i], nb, Fo4);
}
for(i=0;i<na;i++){
amax=0.0;
for(j=0;j<nb;j++)
if(fabs(sn1[i][j])>amax) amax=fabs(sn1[i][j]);
amp1[i]=amax;
amax=0.0;
for(j=0;j<nb;j++)
if(fabs(sn2[i][j])>amax) amax=fabs(sn2[i][j]);
amp2[i]=amax;
}
amax1=0.0;
amax2=0.0;
for(i=na/2-2;i<na/2+2;i++){
if(amp1[i]>amax1) amax1=amp1[i];
if(amp2[i]>amax2) amax2=amp2[i];
}
for(i=0;i<na;i++){
amp1[i] /= amax1;
amp2[i] /= amax2;
}
sf_floatwrite(amp1, na, Fo5);
sf_floatwrite(amp2, na, Fo6);
free(*snap1);
free(*snap2);
free(*sn1);
free(*sn2);
free(amp1);
free(amp2);
}
