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); }