segypp.hh

Go to the documentation of this file.

#ifndef __TSOPT_SEGYPP
#define __TSOPT_SEGYPP

#include "space.hh"
#include "locallinalg.hh"
#include "ocdc.hh"
#include "su.h"
#include "header.h"
#include "segy.h"
#include "parserdecl.hh"
#include "iwave_fopen.h"
#include "utils.h"

// uncomment for verbose output
//#define FRUITCAKE

/* forward declarations for CP<segy> functions, and specialization
   of pair extractor
*/

namespace RVL {

  template<>
  size_t getDataSize<segy>(segy const & md);
  template<>
  float * newData<float,segy>(segy & md);
  template<>
  void deleteData<float,segy>(float ** d,segy ** md);
  template<>
  ostream & writeMeta<segy>(segy const & md, ostream & s);
  /*
  template<>
  class PairExtractor< segy > {
  public:
    PairExtractor() {}
    PairExtractor(PairExtractor< segy > const &) {}
    ~PairExtractor() {}
    
    static STRING_PAIR extract(string in) {
      STRING_PAIR pr;
      pr.key="datafile";
      pr.val=in;
      return pr;
    }
  };
  */
}

// standalone global namespace function
int count_unique_flthdr(std::string fpath, std::string key, float tol=1.e-3);

namespace TSOpt {

  using RVL::getDataSize;
  using RVL::newData;
  using RVL::deleteData;
  using RVL::ContentPackage;
  using RVL::PackageContainer;
  using RVL::PackageContainerFactory;
  using RVL::OCDC;
  using RVL::STRING_PAIR;
  //  using RVL::PairExtractor;
  using RVL::ConstContainer;
  using RVL::Space;
  using RVL::StdSpace;
  using RVL::Vector;
  using RVL::DataContainer;
  using RVL::DataContainerFactory;  
  using RVL::FunctionObject;
  using RVL::FunctionObjectScalarRedn;
  using RVL::LinearAlgebraPackage;
  using RVL::RVLLinearAlgebraPackage;
  using RVL::RVLException;
  using RVL::Writeable;

  typedef ContentPackage<float,segy> segytrace;

  /* forward declaration */
  class segygen;

  class SEGYDC: public OCDC<float,segy> {

  private:

    string hdr;            // name of prototype SU file
    mutable segy tr;       // workspace for reads, proto for segytrace
    segytrace * buf;       // read buffer, get returns ref
    mutable FILE * fp;     // stream for data i/o
    mutable bool rd;       // set if last op is read, unset on write
    mutable off_t off_cur; // offset of current trace in bytes
    ostream & outfile;     // verbose output file

    FILE * fph;            // stream for prototype i/o
    off_t off_eof;         // prototype end-of-file offset in bytes
    int nb;                // prototype number of bytes per trace
    int ns;                // prototype number of samples per trace
    int dt;                // prototype sample rate

    SEGYDC();
    SEGYDC(SEGYDC const &);

  protected:

    void open_p() const;
    segytrace & get(bool & more);
    segytrace const & get(bool & more) const;
    void put() const;
    void reset() const;

  public:

    SEGYDC(string _hdr, ostream & _outfile = cerr);
    ~SEGYDC();

    string getHdr() const { return hdr; }
    ostream & write(ostream & str) const;

  };

  class SEGYDCF: public PackageContainerFactory<float,segy> {

  private:

    /* initialized on construction */
    string hdr;        // name of prototype file
    ostream & outfile; // verbose output stream

    /* post-construction initialization */
    mutable int nb;    // number of bytes for all traces
    mutable int nt;    // number of time samples
    mutable float dt;  // time step (scale in L2 norm)
    mutable bool iflag;
    void init() const;

    SEGYDCF();

  protected:

    SEGYDC * buildSEGY() const {
      init();
      return new SEGYDC(hdr,outfile);
    }
    PackageContainer<float,segy> * buildPC() const {
      return buildSEGY();
    }

  public: 

    SEGYDCF(string _hdr, ostream & _outfile=cerr);

    SEGYDCF(SEGYDCF const & f) 
      : hdr(f.hdr), outfile(f.outfile), iflag(false) {}

    ~SEGYDCF() {}

    SEGYDCF * cloneSEGY() const { 
      return new SEGYDCF(*this); 
    }

    PackageContainerFactory<float,segy> * clone() const { 
      return cloneSEGY();
    } 

    string getFilename() const { return hdr; }
    
    float getDt() const { init(); return dt; }

    int getNt() const { init(); return nt; }

    int getNB() const { init(); return nb; }

    bool compare( DataContainerFactory const & dcf) const;
    bool isCompatible( DataContainer const & dc ) const;
    ostream & write(ostream & str) const;
  };

  class SEGYSpace: public StdSpace<float,float>,
           public ConstContainer<STRING_PAIR> {
    
  private:
    
    SEGYDCF f;
    RVLLinearAlgebraPackage<float> l;

  protected:

    Space<float> * clone() const {
      return new SEGYSpace(*this);
    }

  public:

    SEGYSpace(string hdr, string key, ostream & outfile = cerr)
      : StdSpace<float,float>(),
    //  ConstContainer<STRING_PAIR>(PairExtractor< segy >::extract(hdr)),
    ConstContainer<STRING_PAIR>(STRING_PAIR(key,hdr)),
    f(hdr,outfile),
    l(f.getDt()) {}
    SEGYSpace(SEGYSpace const & sp) 
      : StdSpace<float,float>(sp),
    ConstContainer<STRING_PAIR>(sp.get()),
    f(sp.f), l(sp.l) {}
    ~SEGYSpace() {}

    // can only be called by other spaces, since base class operator new is protected
    //    SEGYSpace * clone() { return new SEGYSpace(*this); }

    DataContainerFactory const & getDCF() const { return f; }
    LinearAlgebraPackage<float> const & getLAP() const { return l; }

    string getPrototypeFilename() const { return f.getFilename(); }
    
    float getDt() const { 
      try { 
    return f.getDt(); }
      catch (RVLException & e) {
    e<<"\ncalled from SEGYSpace::getDt\n";
    throw e;
      }
    }
    int getNt() const { 
      try {
    return f.getNt(); }
      catch  (RVLException & e) {
    e<<"\ncalled from SEGYSpace::getNt\n";
    throw e;
      }
    }
    
    ostream & write(ostream & str) const;
  };    
    
}

#endif

---