DC.h

Go to the documentation of this file.

#include <vector>
#include <algorithm>
#include <map>
#include <iostream>
#include <vapor/MyBase.h>

#ifndef _DC_H_
#define _DC_H_

namespace VAPoR {

class VDF_API DC : public VetsUtil::MyBase {
public:

 //
 enum XType {INVALID = -1, FLOAT, DOUBLE, INT32, INT64, TEXT};

 class Dimension {
 public:

  Dimension() {
    _name.clear();
    _length = 0;
    _axis = 0;
  };

  Dimension(std::string name, size_t length, int axis) { 
    _name = name;
    _length = length;
    _axis = axis;
  };
  virtual ~Dimension() {};

  void Clear() {
    _name.clear();
    _length = 0;
    _axis = 0;
  }

  //
  string GetName() const {return (_name); };

  //
  void SetName(string name) {_name = name;};

  //
  size_t GetLength() const {return (_length); };

  //
  void SetLength(size_t length) {_length = length;};

  //
  int GetAxis() const {return (_axis); };

  //
  void SetAxis(int axis) {_axis = axis;};

  bool operator==(const Dimension &rhs) const {
    return(_name == rhs._name && _length==rhs._length && _axis==rhs._axis);
  }
  bool operator!=(const Dimension &rhs) const {
    return(! (*this==rhs));
  }
  friend std::ostream &operator<<(
    std::ostream &o, const Dimension &dimension
  );

 private:
  string _name;
  size_t _length;
  int _axis;
 };

 class Attribute {
 public:
  Attribute() {_name = ""; _type = FLOAT; _values.clear(); };

  //
  Attribute(string name, XType type, const std::vector <float> &values);
  Attribute(string name, XType type, const std::vector <double> &values);
  Attribute(string name, XType type, const std::vector <int> &values);
  Attribute(string name, XType type, const std::vector <long> &values);
  Attribute(string name, XType type, const string &values);
  Attribute(string name, XType type) {
    _name = name; _type = type; _values.clear(); 
  };
  virtual ~Attribute() {};

  //
  string GetName() const {return (_name); };

  //
  XType GetXType() const {return (_type);};

  void GetValues(std::vector <float> &values) const;
  void GetValues(std::vector <double> &values) const;
  void GetValues(std::vector <int> &values) const;
  void GetValues(std::vector <long> &values) const;
  void GetValues(string &values) const;

  void SetValues(const std::vector <float> &values);
  void SetValues(const std::vector <double> &values);
  void SetValues(const std::vector <int> &values);
  void SetValues(const std::vector <long> &values);
  void SetValues(const string &values);

  friend std::ostream &operator<<(std::ostream &o, const Attribute &attr);

 private:
  string _name;
  XType _type;
  union podunion {
   float f;
   double d;
   int i;
   long l;
   char c;
  };
  std::vector <podunion> _values;
  
 };

  //
 class BaseVar {
 public:

  BaseVar() {
      _name.clear();
      _dimensions.clear();
      _units = "";
      _type = FLOAT;
      _wname = "";
      _cratios.clear();
      _bs.clear();
      _periodic.clear();
      _atts.clear();
  }

  BaseVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, 
    std::vector <size_t> bs, string wname, 
    std::vector <size_t> cratios, std::vector <bool> periodic
  ) :
    _name(name),
    _dimensions(dimensions),
    _units(units),
    _type(type),
    _wname(wname),
    _cratios(cratios),
    _bs(bs),
    _periodic(periodic)
  {
    if (_cratios.size()==0) _cratios.push_back(1);
    for (int i=_bs.size(); i<_dimensions.size(); i++) _bs.push_back(1);
  };

  BaseVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, std::vector <bool> periodic
  );

  virtual ~BaseVar() {};

  //
  string GetName() const {return (_name); };
  void SetName(string name) {_name = name; };

  //
  std::vector <DC::Dimension> GetDimensions() const {return (_dimensions); };
  void SetDimensions(std::vector <DC::Dimension> dimensions) {
    _dimensions = dimensions;
  };

  //
  string GetUnits() const {return (_units); };
  void SetUnits(string units) {_units = units; };

  //
  XType GetXType() const {return (_type); };
  void SetXType(XType type) {_type = type; };


  //
  std::vector <size_t> GetBS() const {return (_bs); };
  void SetBS(std::vector <size_t> bs) {_bs = bs; };

  //
  string GetWName() const {return (_wname); };
  void SetWName(string wname) {_wname = wname; };

  //
  std::vector <size_t> GetCRatios() const {return (_cratios); };
  void SetCRatios(std::vector <size_t> cratios) {
    _cratios = cratios;
    if (_cratios.size()==0) _cratios.push_back(1);
  };

  //
  std::vector <bool> GetPeriodic() const {return (_periodic); };
  void SetPeriodic(std::vector <bool> periodic) { _periodic = periodic; };

  //
  std::map <string, Attribute> GetAttributes() const {return (_atts); };
  void SetAttributes(std::map <string, Attribute> &atts) {_atts = atts; };

  //
  bool IsCompressed() const { return (! _wname.empty()); };

  //
  bool IsTimeVarying() const { 
    for (int i=0; i<_dimensions.size(); i++) {
        if (_dimensions[i].GetAxis() == 3) return(true);
    }
    return(false);
  };

  friend std::ostream &operator<<(std::ostream &o, const BaseVar &var);
  
 private:
  string _name;
  std::vector <DC::Dimension> _dimensions;
  string _units;
  XType _type;
  string _wname;
  std::vector <size_t> _cratios;
  vector <size_t> _bs;
  std::vector <bool> _periodic;
  std::map <string, Attribute> _atts;
 };

 //
 class CoordVar : public BaseVar {
 public:

  //
  CoordVar() : BaseVar() {
    _axis = 0;
    _uniform = false;
  }


  //
  CoordVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, 
    std::vector <size_t> bs, string wname, 
    std::vector <size_t> cratios, std::vector <bool> periodic, 
    int axis, bool uniform
  ) :
    BaseVar(
        name, dimensions, units, type, bs, 
        wname, cratios,
        periodic
    ),
    _axis(axis),
    _uniform(uniform)
 {}

  //
  CoordVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, 
    std::vector <bool> periodic, 
    int axis, bool uniform
  ) :
    BaseVar(name, dimensions, units, type, periodic),
    _axis(axis),
    _uniform(uniform)
 {}

  virtual ~CoordVar() {};

  //
  int GetAxis() const {return (_axis); };
  void SetAxis(int axis) {_axis = axis; };

  //
  bool GetUniform() const {return (_uniform); };
  void SetUniform(bool uniform) {_uniform = uniform; };

  friend std::ostream &operator<<(std::ostream &o, const CoordVar &var);

 private:
  int _axis;
  bool _uniform;
 };

 class DataVar : public BaseVar {
 public:

  //
  DataVar() : BaseVar() {
    _coordvars.clear();
    _maskvar = "";
    _has_missing = false;
    _missing_value = 0.0;
  }

  DataVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, 
    std::vector <size_t> bs, string wname,
    std::vector <size_t> cratios,
    std::vector <bool> periodic, std::vector <string> coordvars, 
    double missing_value
  ) :
    BaseVar(
        name, dimensions, units, type, 
        bs, wname, cratios, periodic
    ),
    _coordvars(coordvars),
    _maskvar(""),
    _has_missing(true),
    _missing_value(missing_value)
  {}

  DataVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, 
    std::vector <size_t> bs, string wname,
    std::vector <size_t> cratios,
    std::vector <bool> periodic, std::vector <string> coordvars, 
    double missing_value, string maskvar
  ) :
    BaseVar(
        name, dimensions, units, type, 
        bs, wname, cratios, periodic
    ),
    _coordvars(coordvars),
    _maskvar(maskvar),
    _has_missing(true),
    _missing_value(missing_value)
  {}

  DataVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, 
    std::vector <size_t> bs, string wname,
    std::vector <size_t> cratios,
    std::vector <bool> periodic, std::vector <string> coordvars
  ) :
    BaseVar(
        name, dimensions, units, type, 
        bs, wname, cratios, periodic
    ),
    _coordvars(coordvars),
    _maskvar(""),
    _has_missing(false),
    _missing_value(0.0)
  {}

  DataVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, 
    std::vector <bool> periodic, std::vector <string> coordvars, 
    double missing_value
  ) : 
    BaseVar(
        name, dimensions, units, type, periodic
    ),
    _coordvars(coordvars),
    _maskvar(""),
    _has_missing(true),
    _missing_value(missing_value)
    {}

  DataVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, 
    std::vector <bool> periodic, std::vector <string> coordvars, 
    double missing_value, string maskvar
  ) : 
    BaseVar(
        name, dimensions, units, type, periodic
    ),
    _coordvars(coordvars),
    _maskvar(maskvar),
    _has_missing(true),
    _missing_value(missing_value)
    {}

  DataVar(
    string name, std::vector <DC::Dimension> dimensions,
    string units, XType type, 
    std::vector <bool> periodic, std::vector <string> coordvars
  ) : 
    BaseVar(
        name, dimensions, units, type, periodic
    ),
    _coordvars(coordvars),
    _maskvar(""),
    _has_missing(false),
    _missing_value(0.0)
    {}


  virtual ~DataVar() {};

  //
  std::vector <string> GetCoordvars() const {return (_coordvars); };
  void SetCoordvars(std::vector <string> coordvars) {_coordvars = coordvars; };

  //
  string GetMaskvar() const {return (_maskvar); };
  void SetMaskvar(string maskvar) {_maskvar = maskvar; };

  //
  bool GetHasMissing() const {return (_has_missing); };
  void SetHasMissing(bool has_missing) {_has_missing = has_missing; };

  //
  double GetMissingValue() const {return (_missing_value); };
  void SetMissingValue(double missing_value) {_missing_value = missing_value; };

 VDF_API friend std::ostream &operator<<(std::ostream &o, const DataVar &var);

 private:
  std::vector <string> _coordvars;
  string _maskvar;
  bool _has_missing;
  double _missing_value;
 };



 DC() {};
 virtual ~DC() {}

 //
 virtual int Initialize(const vector <string> &paths) = 0;


 virtual bool GetDimension(
    string dimname, DC::Dimension &dimension
 ) const = 0;

 virtual std::vector <string> GetDimensionNames() const = 0;

 virtual bool GetCoordVarInfo(string varname, DC::CoordVar &cvar) const = 0;

 virtual bool GetDataVarInfo( string varname, DC::DataVar &datavar) const = 0;
 
 //
 virtual bool GetBaseVarInfo(string varname, DC::BaseVar &var) const = 0;


 //
 virtual std::vector <string> GetDataVarNames() const = 0;


 //
 virtual std::vector <string> GetCoordVarNames() const = 0;


 //
 virtual int GetNumRefLevels(string varname) const = 0;


 //
 virtual int GetAtt(
    string varname, string attname, vector <double> &values
 ) const = 0;
 virtual int GetAtt(
    string varname, string attname, vector <long> &values
 ) const = 0;
 virtual int GetAtt(
    string varname, string attname, string &values
 ) const = 0;

 //
 virtual std::vector <string> GetAttNames(string varname) const = 0;

 virtual XType GetAttType(string varname, string attname) const = 0;

 //
 virtual int GetDimLensAtLevel(
    string varname, int level, std::vector <size_t> &dims_at_level,
    std::vector <size_t> &bs_at_level
 ) const = 0;

 //
 virtual int GetMapProjection(
    string lonname, string latname, string &projstring
 ) const = 0;


 //
 virtual int OpenVariableRead(
    size_t ts, string varname, int level=0, int lod=0
 ) = 0;


 //
 virtual int CloseVariable() = 0;

 //
 int virtual Read(float *data) = 0;

 virtual int ReadSlice(float *slice) = 0;

 //
 virtual int ReadRegion(
    const vector <size_t> &min, const vector <size_t> &max, float *region
 ) = 0;

 virtual int ReadRegionBlock(
    const vector <size_t> &min, const vector <size_t> &max, float *region
 ) = 0;

 //
 virtual int GetVar(string varname, int level, int lod, float *data) = 0;

 //
 virtual int GetVar(
    size_t ts, string varname, int level, int lod, float *data
 ) = 0;


 //
 virtual bool VariableExists(
    size_t ts,
    string varname,
    int reflevel = 0,
    int lod = 0
 ) const = 0;


 //
 // The following are convenience methods provided by the DC base 
 // class. In general they should NOT need to be reimplimented by
 // derived classes.
 //

 virtual bool GetDimension(
    string dimname, size_t &length, int &axis
 ) const;

 //
 virtual std::vector <string> GetDataVarNames(int ndim, bool spatial) const;


 //
 //
 virtual std::vector <string> GetCoordVarNames(int ndim, bool spatial) const;

 virtual bool IsTimeVarying(string varname) const;

 //
 virtual bool IsCompressed(string varname) const;

 //
 virtual int GetNumTimeSteps(string varname) const;

 //
 virtual int GetCRatios(string varname, vector <size_t> &cratios) const;


 virtual bool IsDataVar(string varname) const {
    vector <string> names = GetDataVarNames();
    return(find(names.begin(), names.end(), varname) != names.end());
 }

 virtual bool IsCoordVar(string varname) const {
    vector <string> names = GetDataVarNames();
    return(find(names.begin(), names.end(), varname) != names.end());
 }

 //
 virtual int GetMapProjection(string varname, string &projstring) const;

 //
 static bool ParseDimensions(
    const vector <DC::Dimension> &dimensions,
    vector <size_t> &sdims, size_t &numts
 );


};
};

#endif