VDC.h

Go to the documentation of this file.

#include <vector>
#include <map>
#include <iostream>
#include <vapor/DC.h>
#include <vapor/MyBase.h>
#include <vapor/UDUnitsClass.h>
 
#ifndef _VDC_H_
    #define _VDC_H_
 
namespace VAPoR {
 
class VDF_API VDC : public VAPoR::DC {
public:
    enum AccessMode { R, W, A };
 
    VDC();
    virtual ~VDC() {}
 
protected:
    //
    virtual int initialize(const std::vector<string> &paths, const std::vector<string> &options, AccessMode mode, vector<size_t> bs);
    virtual int initialize(const std::vector<string> &paths, const std::vector<string> &options) { return (initialize(paths, options, R, vector<size_t>())); }
 
public:
    //
    int SetCompressionBlock(string wname, std::vector<size_t> cratios);
 
    //
    void GetCompressionBlock(std::vector<size_t> &bs, string &wname, std::vector<size_t> &cratios) const;
 
    void SetPeriodicBoundary(std::vector<bool> periodic)
    {
        _periodic = periodic;
        for (int i = _periodic.size(); i < 3; i++) _periodic.push_back(false);
    }
 
    //
    std::vector<bool> GetPeriodicBoundary() const { return (_periodic); };
 
    //
    int DefineDimension(string dimname, size_t length);
 
    //
    int DefineDimension(string dimname, size_t length, int axis);
 
protected:
    //
    bool getDimension(string dimname, DC::Dimension &dimension) const;
 
    //
    std::vector<string> getDimensionNames() const;
 
    //
    std::vector<string> getMeshNames() const;
 
    virtual bool getMesh(string mesh_name, DC::Mesh &mesh) const;
 
    //
    bool getCoordVarInfo(string varname, DC::CoordVar &cvar) const;
 
    //
    bool getDataVarInfo(string varname, DC::DataVar &datavar) const;
 
    //
    bool getAuxVarInfo(string varname, DC::AuxVar &var) const { return (false); }
 
    //
    bool getBaseVarInfo(string varname, DC::BaseVar &var) const;
 
    virtual std::vector<string> getDataVarNames() const;
 
    virtual std::vector<string> getAuxVarNames() const { return (vector<string>()); }
 
    virtual std::vector<string> getCoordVarNames() const;
 
    //
    size_t getNumRefLevels(string varname) const;
 
    bool getAtt(string varname, string attname, vector<double> &values) const;
    bool getAtt(string varname, string attname, vector<long> &values) const;
    bool getAtt(string varname, string attname, string &values) const;
 
    std::vector<string> getAttNames(string varname) const;
 
    XType getAttType(string varname, string attname) const;
 
    virtual vector<size_t> getBlockSize() const { return (_bs); }
 
    virtual int getDimLensAtLevel(string varname, int level, std::vector<size_t> &dims_at_level, std::vector<size_t> &bs_at_level) const = 0;
 
    virtual string getMapProjection(string varname) const;
 
    virtual string getMapProjection() const;
 
    virtual string getMapProjectionDefault() const { return (getMapProjection()); }
 
    virtual int openVariableRead(size_t ts, string varname, int level = 0, int lod = 0) = 0;
 
    virtual int closeVariable(int fd) = 0;
 
    virtual int readRegion(int fd, const vector<size_t> &min, const vector<size_t> &max, float *region) = 0;
    virtual int readRegion(int fd, const vector<size_t> &min, const vector<size_t> &max, double *region) = 0;
 
public:
    //
    int DefineCoordVar(string varname, std::vector<string> dimnames, string time_dim_name, string units, int axis, XType type, bool compressed);
 
    //
    int DefineCoordVarUniform(string varname, std::vector<string> dimname, string time_dim_name, string units, int axis, XType type, bool compressed);
 
    int DefineDataVar(string varname, std::vector<string> dimnames, std::vector<string> coordvars, string units, XType type, bool compressed);
 
    int DefineDataVar(string varname, std::vector<string> dimnames, std::vector<string> coordvars, string units, XType type, double missing_value, string maskvar);
 
    //
    int PutAtt(string varname, string attname, XType type, const vector<double> &values);
    int PutAtt(string varname, string attname, XType type, const vector<long> &values);
    int PutAtt(string varname, string attname, XType type, const string &values);
 
    //
    int CopyAtt(const DC &src, string varname, string attname);
 
    //
    int CopyAtt(const DC &src, string varname);
 
    //
    virtual int SetMapProjection(string varname, string projstring);
 
    virtual int SetMapProjection(string projstring);
 
    int EndDefine();
 
    virtual int GetPath(string varname, size_t ts, string &path, size_t &file_ts, size_t &max_ts
 
    ) const = 0;
 
    //
    virtual int OpenVariableWrite(size_t ts, string varname, int lod = -1) = 0;
 
    virtual int CloseVariableWrite(int fd) = 0;
 
    //
    virtual int Write(int fd, const float *data) = 0;
    virtual int Write(int fd, const int *data) = 0;
 
    virtual int WriteSlice(int fd, const float *slice) = 0;
    virtual int WriteSlice(int fd, const int *slice) = 0;
    virtual int WriteSlice(int fd, const unsigned char *slice) = 0;
 
    //
    virtual int PutVar(string varname, int lod, const float *data) = 0;
    virtual int PutVar(string varname, int lod, const int *data) = 0;
 
    //
    virtual int PutVar(size_t ts, string varname, int lod, const float *data) = 0;
    virtual int PutVar(size_t ts, string varname, int lod, const int *data) = 0;
 
    virtual int CopyVar(DC &dc, string varname, int srclod, int dstlod) = 0;
 
    //
    virtual int CopyVar(DC &dc, size_t ts, string varname, int srclod, int dstlod) = 0;
 
    virtual bool CompressionInfo(vector<size_t> bs, string wname, size_t &nlevels, size_t &maxcratio) const = 0;
 
    //
    virtual bool variableExists(size_t ts, string varname, int reflevel = 0, int lod = 0) const = 0;
 
    friend std::ostream &operator<<(std::ostream &o, const VDC &vdc);
 
private:
    string              _proj4StringOption;
    std::vector<string> _newUniformVars;
 
protected:
    string              _master_path;
    AccessMode          _mode;
    bool                _defineMode;
    std::vector<size_t> _bs;
    string              _wname;
    std::vector<size_t> _cratios;
    vector<bool>        _periodic;
    VAPoR::UDUnits      _udunits;
 
    std::map<string, Dimension> _dimsMap;
    std::map<string, Attribute> _atts;
    std::map<string, CoordVar>  _coordVars;
    std::map<string, DataVar>   _dataVars;
    std::map<string, Mesh>      _meshes;
 
    #ifndef DOXYGEN_SKIP_THIS
 
    bool _ValidDefineDimension(string name, size_t length) const;
 
    bool _ValidDefineCoordVar(string varname, vector<string> dimnames, string time_dim_name, string units, int axis, XType type, bool compressed) const;
 
    bool _valid_blocking(const vector<DC::Dimension> &dimensions, const vector<size_t> &bs, const vector<string> &coordvars) const;
 
    bool _valid_mask_var(string varname, vector<DC::Dimension> dimensions, vector<size_t> bs, bool compressed, string maskvar) const;
 
    bool _ValidDefineDataVar(string varname, vector<string> dimnames, vector<string> coordnames, string units, XType type, bool compressed, bool has_missing, string maskvar) const;
 
    bool _ValidCompressionBlock(vector<size_t> bs, string wname, vector<size_t> cratios) const;
 
    bool _valid_dims(const vector<DC::Dimension> &dims0, const vector<size_t> &bs0, const vector<DC::Dimension> &dims1, const vector<size_t> &bs1) const;
 
    virtual int _WriteMasterMeta() = 0;
    virtual int _ReadMasterMeta() = 0;
 
    void _DefineMesh(string meshname, vector<string> dim_names, vector<string> coord_vars);
 
    int _DefineDataVar(string varname, std::vector<string> dimnames, std::vector<string> coordvars, string units, XType type, bool compressed, bool has_missing, double mv, string maskvar);
 
    vector<string> _GetCoordVarDimNames(const CoordVar &var, bool &time_varying) const;
 
    vector<string> _GetDataVarDimNames(const DataVar &var, bool &time_varying) const;
 
    int _DefineImplicitCoordVars(vector<string> dim_names, vector<string> coord_vars_in, vector<string> &coord_vars_out);
 
    #endif
};
};    // namespace VAPoR
 
#endif