gridpp.hh

Go to the documentation of this file.

#ifndef __TSOPT_GRIDPP
#define __TSOPT_GRIDPP

//#define FRUITCAKE
//#define VERBOSE

#define MAX_NAMELEN 128

#include "space.hh"
#include "locallinalg.hh"
#include "ocdc.hh"
#include "parserdecl.hh"
#include "iwave_fopen.h"
#include "grid.h"
#include "gridio.h"
#include "rarray.h"
#include "write.hh"

namespace RVL {

  template<>
  size_t getDataSize<RARR>(RARR const & a);

  template<>
  ireal * newData<ireal,RARR>(RARR & md);

  template<>
  void deleteData<ireal,RARR>(ireal ** d,RARR ** md);

  template<>
  ostream & writeMeta<RARR>(RARR const & md, ostream & s);

}

namespace TSOpt {

  using RVL::OCDC;
  using RVL::ConstContainer;
  using RVL::STRING_PAIR;
  using RVL::RVLException;
  using RVL::ScalarFieldTraits;
  using RVL::DataContainer;
  using RVL::ContentPackage;
  using RVL::PackageContainer;
  using RVL::DataContainerFactory;
  using RVL::PackageContainerFactory;
  using RVL::getDataSize;
  using RVL::Writeable;
  using RVL::Space;
  using RVL::StdSpace;
  using RVL::LinearAlgebraPackage;
  using RVL::RVLLinearAlgebraPackage;
  using RVL::parse;

  class GridDC: public OCDC<ireal, RARR> {

  private:

    /* constructor argument copies */
    string const & protohdr;  // name of prototype RSF header file
    string const & protodata; // name of prototype RSF data file
    grid const & protog;      // created from prototype RSF header file
    string data_format;       // read from prototype RSF header file
    ostream & outfile;        // verbose output stream
    
    /* internally generated in open_p - must be mutable */
    mutable FILE * fph;       // header file stream
    mutable FILE * fp;        // data file stream
    mutable string datafile;  // guess

    // read buffer
    mutable ContentPackage<ireal,RARR> buf;
    mutable int panelindex;   // chunk index
    int panelnum;             // number of chunks
    mutable bool rd;          // set if last op is read, unset on write

    GridDC();
    GridDC(GridDC const &);

  protected:

    void open_p() const;
    ContentPackage<ireal,RARR> & get(bool & more);
    ContentPackage<ireal,RARR> const & get(bool & more) const;
    void put() const;
    void reset() const;

  public:
    
    GridDC(string const & _protohdr,
       string const & _protodata,
       grid const & _protog,
       string const & _data_format,
       string data_type,
       bool incore = false,
       ostream & _outfile = cerr);
    ~GridDC();
    bool isInCore() const;
    string getProtohdr() const;
    ostream & write(ostream & str) const;

  };
  
  class GridDCF: public PackageContainerFactory<ireal, RARR> {
    
  private:
    
    string protohdr;        // name of prototype RSF metadata file
    string protodata;       // name of prototype RSF data file
    string data_format;     // data format
    string data_type;       // data type tag
    ostream & outfile;      // externally supplied verbose output unit
    grid protog;            // grid determined by metadata
    ireal scfac;            // scale factor (from units)
    bool incore;            // RVL::Vector ops done incore
    ireal vol;              // cell volume
    
    GridDCF();

  protected:

    GridDC * buildGridDC() const;
    PackageContainer<ireal, RARR> * buildPC() const;

  public:

    GridDCF(string _protohdr, bool _incore=false, ostream & _outfile = cerr);

    GridDCF(GridDCF const & f);
    ~GridDCF();
    
    PackageContainerFactory<ireal, RARR> * clone() const;
    grid const & getGrid() const;
    ireal getCellVol() const;
    ireal getScaleFactor() const;
    string getFilename() const;
    bool compare( DataContainerFactory const & dcf) const;

    // compatible if either DFC incore flag is unset (whether data is incore or not)
    // or DFC incore flag is set and DC data is incore for any reason (i.e. internal
    // grid has dim=gdim).
    bool isCompatible( DataContainer const & dc ) const;
    bool isIncore() const;
    ostream & write(ostream & str) const;

  };

  class GridSpace: public StdSpace<ireal,ireal>,
           public ConstContainer<STRING_PAIR> {
    
  private:
    
    GridDCF f; 
    RVLLinearAlgebraPackage<ireal> l;
    
    STRING_PAIR getPTblEntry(grid const & g,
                 std::string tag,
                 std::string & thdr,
                 std::string fmt);

  protected:

    Space<float> * clone() const {
      return new GridSpace(*this);
    }
    
  public:

    GridSpace(string hdr, 
          string dtype = "notype", 
          bool incore = false,
          ostream & outfile = cerr);

    GridSpace(grid const & g,
          std::string tag,
          std::string thdr="",
          std::string fmt="native_ireal",
          bool incore=false,
          ostream & outfile = cerr);
    GridSpace(GridSpace const & sp);
    ~GridSpace();

    LinearAlgebraPackage<ireal> const & getLAP() const;
    DataContainerFactory const & getDCF() const;
    grid const & getGrid() const;
    bool isIncore() const;
    ostream & write(ostream & str) const;
  };
}         
      
#endif

---