traceio.h

Go to the documentation of this file.

#ifndef __SEAM_TRACEIO
#define __SEAM_TRACEIO

/* uncomment to force use of file manager */
#define IWAVE_USE_FMGR

#include "utils.h"
#include "usempi.h"
#include "cubic.h"
/* added 05.03.10 */
#ifdef IWAVE_USE_FMGR
#include "iwave_fopen.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif
#include "su.h"
#include "header.h"
#include "segy.h"
#ifdef __cplusplus
}
#endif

/* max number of traces permitted in record */
#define MAX_TRACES 500000  
/* max number of records permitted in data */
#define MAX_RECS 1000
/* tolerance for shot position (fraction of space step) */
#define SRC_TOL 0.001
/* end-of-file flag - should be disinct from other error returns */
#define W_EOF -10

void mygethdval(segy * tr, const char * ch, Value * val);
void myputhdval(segy * tr, const char * ch, Value * val);

typedef struct s_offsegy {
  off_t m;
  segy tr;
} offsegy;

typedef struct s_tracegeom {

  int nrec;
  int irec;
  int xrec;
  int first;
  int last;
  /*  int ntr[MAX_RECS]; */
  int * ntr;
  /*  off_t recoff[MAX_RECS]; */
  off_t * recoff;
  /*  RPNT src[MAX_RECS]; */
  RPNT * src;
  int ntraces;     
  /*  IPNT ig[MAX_TRACES]; */
  IPNT * ig;
  /*  RPNT rg[MAX_TRACES]; */
  RPNT * rg;
  IPNT is;
  RPNT rs;
  IPNT axord;
  int nt;
  int ntout;
  float dt;
  float dtout;
  int dtmus;
  float tmax;
  float t0;
  float t0out;
  /*  int tracl[MAX_TRACES]; */
  int * tracl;
  /*  int tracr[MAX_TRACES]; */
  int * tracr;
  /*  int fldr[MAX_TRACES]; */
  int * fldr;
  /*  int tracf[MAX_TRACES]; */
  int * tracf;
  int scalel;
  int scalco;
  float * buf;
  int interp;
  int ndim;
  ireal dvol;
  FILE * fpin;
  /*  off_t troff[MAX_TRACES]; */
  off_t * troff;
#ifdef IWAVE_USE_MPI

  MPI_Datatype p;
#endif
} tracegeom;

int construct_tracegeom(tracegeom * tg,
            const char * fin,
            float dt,
            float tol,
            FILE * stream);

// added irec - external control of record 11.01.14
int init_tracegeom(tracegeom * tg, 
           int irec,
           RPNT og,
           IPNT n, RPNT d, RPNT o, 
           IPNT axord,
           int order,
           int ndim,
           int initbuf,
           FILE * stream);

void destroy_tracegeom(tracegeom * tg);

void setnull_tracegeom(tracegeom * tg);

void fprint_tracegeom(tracegeom const * tg, FILE * fp);

void print_tracegeom(tracegeom const * tg);

/*
  outdated material:

    Version 1.1 addendum: this function now both samples the field to the
    output trace buffer (save mode), and adjoint-samples the trace buffer
    onto the field (load) mode. The load flag determines which option is
    taken. In load mode, an additional option is provided to scale the 
    updated field values by another multiplier field and multiplication by
    the time step. This option is switched by the multiplier field pointer; 
    a null value indicates no scaling. Global grid geometry data supplied,
    since this array may not have same size and shape as sampled field, so
    offsets must be computed independently.

    @param[in] allocstrides_mult (\ref IPNT) number of samples on each
    local ALLOCATED grid axis for multiplier array;
    @param[in] allocorigs_mult (\ref IPNT) index tuple of local ALLOCATED grid
    origin relative to global grid for multiplier array;
    @param[in] strides_mult (\ref IPNT) number of samples on each
    local COMPUTATIONAL grid axis (updated points) for multiplier array;
    @param[in] origs_mult (\ref IPNT) index tuple of local COMPUTATIONAL grid 
    origin relative to global grid for multiplier array;
    @param[in] mult (float *) buffer for multiplier field. ignored on save, 
    optionally used to scale input data on load. default value is null, which
    indicates no scaling.
*/
void sampletraces(tracegeom * tg, 
          int order,
          int load,
          int it,
          IPNT allocstrides,
          IPNT allocorigs,
          IPNT strides,
          IPNT origs,
          ireal * field,
          /*          IPNT allocstrides_mult,
          //          IPNT allocorigs_mult,
          //          IPNT strides_mult,
          //          IPNT origs_mult,
          //          int * mult); */
          ireal mult);

void tapermutetraces(tracegeom * tg,
                     int it,
                     float dx,
                     int width,     // width of taper
                     int wtime,     // width of time taper, in ms
                     float mslope,  // slope of mute (dt/dx) (ms/m) 
                     float mzotime, // mute onset at zero offset, time AFTER first sample (ms)
                     float mwidth); // width of mute zone (ms)

int writetraces(tracegeom const * tg, 
        RPNT d,
        RPNT og,
        FILE * stream);

/* 13.03.11: compute first and last record indices for current group
*/
void calc_group(int * first, int * last, int nrec);

void indexrange(tracegeom const * tg,
        IPNT gmin,
        IPNT gmax);

#endif

---