MetadataVDC.h

Go to the documentation of this file.

//
//      $Id$
//


#ifndef _MetadataVDC_h_
#define _MetadataVDC_h_

#include <stack>
#include <string>
#include <expat.h>
#include <vapor/MyBase.h>
#include <vapor/common.h>
#include <vapor/Metadata.h>
#include <vapor/XmlNode.h>
#include <vapor/ExpatParseMgr.h>
#ifdef WIN32
#pragma warning(disable : 4251)
#endif

namespace VAPoR {

//
// Macros to check for required MetadataVDC elements
// Call SetErrMsg if element is not present
//
#define CHK_TS_REQ(TS, RETVAL) \
    if (! _rootnode->GetChild(TS)) { \
        SetErrMsg("Invalid time step : %d", TS); \
        return(RETVAL); \
    }
#define CHK_VAR_REQ(TS, VAR, RETVAL) \
    if (! _rootnode->GetChild(TS)) { \
        SetErrMsg("Invalid time step : %d", TS); \
        return(RETVAL); \
    }; \
    if (! _rootnode->GetChild(TS)->GetChild(VAR)) { \
        SetErrMsg("Invalid variable name : %s", VAR.c_str()); \
        return(RETVAL); \
    }

//
// Macros to check for optional MetadataVDC elements
// Don't call SetErrMsg if element is not present
//
#define CHK_TS_OPT(TS, RETVAL) \
    if (! _rootnode->HasChild(TS)) { \
        return(RETVAL); \
    }
#define CHK_VAR_OPT(TS, VAR, RETVAL) \
    if (! _rootnode->HasChild(TS)) { \
        return(RETVAL); \
    }; \
    if (! _rootnode->GetChild(TS)->HasChild(VAR)) { \
        return(RETVAL); \
    }

const int VDF_VERSION = 5;

//
class VDF_API MetadataVDC : public Metadata, 
    public VetsUtil::MyBase, public ParsedXml {
public:

 //
 MetadataVDC(
    const size_t dim[3], size_t numTransforms, const size_t bs[3],
    int nFilterCoef = 1, int nLiftingCoef = 1, int msbFirst =  1,
    int vdfVersion = VDF_VERSION
 );

 //
 MetadataVDC(
    const size_t dim[3], const size_t bs[3], const vector <size_t> &cratios,
    string wname, string wmode
 );

 //
 MetadataVDC(const string &metafile);

 MetadataVDC(const MetadataVDC &node);


 virtual ~MetadataVDC();

 //
 int Merge(const MetadataVDC &metadata, size_t ts = 0);

 //
 int Merge(const string &path, size_t ts = 0);

 //
 int MakeCurrent() const {return(0); };

 //
 const string &GetParentDir() const { return (_metafileDirName); }

 //
 const string &GetMetafileName() const { return (_metafileName); }

 //
 const string &GetDataDirName() const { return (_dataDirName); }

 int ConstructFullVBase(size_t ts, const string &var, string *path) const;
 int ConstructFullAuxBase(size_t ts, string *path) const;

 //
 int Write(const string &path, int relative_path = 1) ;


 //
 virtual const size_t *GetBlockSize() const { return(_bs); }

 //
 virtual void GetBlockSize(size_t bs[3], int /*reflevel*/) const {
    for (int i=0; i<3; i++) bs[i] = _bs[i];
 }

 virtual void GetGridDim(size_t dim[3]) const {
    for (int i=0; i<3; i++) dim[i] = _dim[i];
 }

 const size_t *GetDimension() const { return(_dim); }

 //
 int GetFilterCoef() const { return(_nFilterCoef); }

 //
 int GetLiftingCoef() const { return(_nLiftingCoef); }

 //
 virtual int GetNumTransforms() const { return(_numTransforms); }

 //
 int GetMSBFirst() const { return(_msbFirst); }

 //
 int GetVDFVersion() const { return(_vdfVersion); }

 //
 string GetWaveName() const { return(_wname); }

 //
 string GetBoundaryMode() const { return(_wmode); }

 //
 virtual vector <size_t> GetCRatios() const { return(_cratios); }

 //
 int GetVDCType() const { return(_vdcType); }



 //------------------------------------------------------------------
 //         Metdata Attributes
 //
 // The methods below get, set, and possibly test various metadata
 // attributes.
 //
 //
 //------------------------------------------------------------------


 //
 int SetGridType(const string &value);

 //
 string GetGridType() const {
    return(_rootnode->GetElementString(_gridTypeTag));
    };

 int IsValidGridType(const string &value) const {
    return(
        (VetsUtil::StrCmpNoCase(value,"regular") == 0) || 
        (VetsUtil::StrCmpNoCase(value,"stretched") == 0) || 
        (VetsUtil::StrCmpNoCase(value,"layered") == 0) || 
        (VetsUtil::StrCmpNoCase(value,"block_amr") == 0)
    );
    }

 //
 int SetCoordSystemType(const string &value);

 //
 string GetCoordSystemType() const {
    return(_rootnode->GetElementString(_coordSystemTypeTag));
    };

 //
 int IsValidCoordSystemType(const string &value) const {
    return(
        (VetsUtil::StrCmpNoCase(value,"cartesian") == 0) || 
        (VetsUtil::StrCmpNoCase(value,"spherical") == 0)
    );
    }

 //
 int SetExtents(const vector<double> &value);

 //
 vector<double> GetExtents(size_t ts = 0) const; 

 //
 int IsValidExtents(const vector<double> &value) const;

 //
 int SetNumTimeSteps(long value);

 //
 long GetNumTimeSteps() const;

 //
 int IsValidTimeStep(long value) const {
    return(value >= 0);
    };

 //
 int SetVariableNames(const vector <string> &value) {
    return (SetVariables3D(value));
 }


 //
 int SetVariables3D(const vector <string> &value);

 //
 vector <string> GetVariables3D() const {
    vector <string> svec;
    _rootnode->GetElementStringVec(_vars3DTag, svec);
    return(svec);
 };

 //
 vector <string> GetCoordinateVariables() const {
    vector <string> svec;
    _rootnode->GetElementStringVec(_coordVarsTag, svec);
    return(svec);
 }

 //
 int SetCoordinateVariables(const vector <string> &value);

 //
 int SetVariables2DXY(const vector <string> &value);
 int SetVariables2DXZ(const vector <string> &value);
 int SetVariables2DYZ(const vector <string> &value);

 //
 vector <string> GetVariables2DXY() const {
    vector <string> svec;
    _rootnode->GetElementStringVec(_vars2DXYTag, svec);
    return(svec);
 };
 vector <string> GetVariables2DXZ() const {
    vector <string> svec;
    _rootnode->GetElementStringVec(_vars2DXZTag, svec);
    return(svec);
 };
 vector <string> GetVariables2DYZ() const {
    vector <string> svec;
    _rootnode->GetElementStringVec(_vars2DYZTag, svec);
    return(svec);
 };


 //
 int SetComment(const string &value) {
    _rootnode->SetElementString(_commentTag, value);
    return(0);
    }

 //
 string GetComment() const {
    return(_rootnode->GetElementString(_commentTag));
 };

 //
 int SetPeriodicBoundary(const vector<long> &value) {
    _rootnode->SetElementLong(_periodicBoundaryTag, value);
    return(0);
 }

 //
 vector<long> GetPeriodicBoundary() const {
    return(_rootnode->GetElementLong(_periodicBoundaryTag));
 };

 //
 int SetGridPermutation(const vector<long> &value) {
    _rootnode->SetElementLong(_gridPermutationTag, value);
    return(0);
 }


 int SetMissingValue(double value) {
    vector <double> valvec; valvec.push_back(value);
    _rootnode->SetElementDouble(_missingValueTag, valvec);
    return(0);
 }

 int SetMissingValue() {
    _rootnode->SetElementDouble(_missingValueTag, _emptyDoubleVec);
    return(0);
 }

 //
 vector<double> GetMissingValue() const {
    return _rootnode->GetElementDouble(_missingValueTag);
 }

 //
 vector<long> GetGridPermutation() const {
    return(_rootnode->GetElementLong(_gridPermutationTag));
 };

 //
 int SetMapProjection(const string &value) {
    _rootnode->SetElementString(_mapProjectionTag, value);
    return(0);
    }

 //
 virtual string GetMapProjection() const;

 //
 int SetTSUserTime(size_t ts, const vector<double> &value);


 //
 double GetTSUserTime(size_t ts) const {
    CHK_TS_OPT(ts, 0.0)
    if (_rootnode->GetChild(ts)->GetElementDouble(_userTimeTag).size())
        return(_rootnode->GetChild(ts)->GetElementDouble(_userTimeTag)[0]);
    else 
        return(ts);
    };

 int SetTSUserTimeStamp(size_t ts, const string &s);

 void GetTSUserTimeStamp(size_t ts, string &s) const {
    if (! _rootnode->GetChild(ts)) {s.clear(); return;}
    s = _rootnode->GetChild(ts)->GetElementString(_userTimeStampTag);
 };



 //
 string GetTSAuxBasePath(size_t ts) const {
    CHK_TS_REQ(ts, _emptyString)
    return(_rootnode->GetChild(ts)->GetElementString(_auxBasePathTag));
    };

 //
 int HasTSUserTime(size_t ts) const {
    if (! _rootnode->HasChild(ts)) return(0);
    return(_rootnode->GetChild(ts)->HasElementDouble(_userTimeTag));
    };

 //
 int IsValidUserTime(const vector<double> &value) const {
    return(value.size() == 1);
    };

 //
 int SetTSXCoords(size_t ts, const vector<double> &value);

 //
 vector<double> GetTSXCoords(size_t ts) const {
    CHK_TS_OPT(ts, _emptyDoubleVec)
    return(_rootnode->GetChild(ts)->GetElementDouble(_xCoordsTag));
 };

 int SetTSYCoords(size_t ts, const vector<double> &value);

 vector<double> GetTSYCoords(size_t ts) const {
    CHK_TS_OPT(ts, _emptyDoubleVec)
    return(_rootnode->GetChild(ts)->GetElementDouble(_yCoordsTag));
 }

 int SetTSZCoords(size_t ts, const vector<double> &value);

 vector<double> GetTSZCoords(size_t ts) const {
    CHK_TS_OPT(ts, _emptyDoubleVec)
    return(_rootnode->GetChild(ts)->GetElementDouble(_zCoordsTag));
 }

 //
 //
 int SetTSComment(size_t ts, const string &value);

 //
 //
 string GetTSComment(size_t ts) const {
    CHK_TS_OPT(ts, _emptyString)
    return(_rootnode->GetChild(ts)->GetElementString(_commentTag));
 }

 //
 int SetTSExtents(size_t ts, const vector<double> &value);

 //
 vector<double> GetTSExtents(size_t ts) const {return (GetExtents(ts)); }

 int SetTSMissingValue(size_t ts, double v);

 //
 vector<double> GetTSMissingValue(size_t ts) const {
    CHK_TS_OPT(ts, _emptyDoubleVec)
    return(_rootnode->GetChild(ts)->GetElementDouble(_missingValueTag));
 }

 //
 int SetVComment(size_t ts, const string &var, const string &value);

 //
 string GetVComment(size_t ts, const string &var) const {
    CHK_VAR_OPT(ts, var, _emptyString)
    return(_rootnode->GetChild(ts)->GetChild(var)->GetElementString(_commentTag));
 }

 //
 string GetVBasePath(size_t ts, const string &var) const;


 int SetVBasePath(
    size_t ts, const string &var, const string &value
 );

 //
 int SetVDataRange(size_t ts, const string &var, const vector<double> &value);

 //
 vector<double> GetVDataRange(size_t ts, const string &var) const {
    CHK_VAR_REQ(ts, var, _emptyDoubleVec)
    return(_rootnode->GetChild(ts)->GetChild(var)->GetElementDouble(_dataRangeTag));
    }

 int IsValidVDataRange(const vector<double> &value) const {
    return(value.size() == 2);
    }

 //
 int SetVMissingValue(size_t ts, const string &var, double v);

 vector<double> GetVMissingValue(size_t ts, const string &var) const {
    CHK_VAR_REQ(ts, var, _emptyDoubleVec)
    return(_rootnode->GetChild(ts)->GetChild(var)->GetElementDouble(_missingValueTag));
 }

 //------------------------------------------------------------------
 //         User-Defined Metdata Attributes
 //
 // The methods below provide a means for the user get and set user-defined
 // attributes. The interpretation of these attributes is solely up
 // to the user. Attributes may be set/get at three "levels"; at the
 // top level, where they may represent global metadata; at the
 // time step level, where the attribute is associated with a 
 // particular time step; and at the variable level, where the attribute
 // is associated with a particular variable, *and* a particular
 // time step.
 // 
 // Overloaded get/set methods exist for attributes of type
 // vector<long>, vector<double>, and string. Addionally, for each 
 // attribute type (long, string, or double) a method is provided for 
 // retrieving the names of all attributes defined of that type.
 //
 // A user-defined attribute is defined whenever it is set via a Set* 
 // method
 //
 // The valid range for the 'ts' parameters in the methods below is
 // [0..NumTS-1], where NumTS is the value returned by method 
 // GetNumTimeSteps.
 //
 // Valid values for the 'var' parameter are those returned by
 // by the GetVariableNames() method.
 //
 //------------------------------------------------------------------

 //------------------------------------------------------------------
 //         Top Level (Global) User-Defined Metdata Attributes
 //
 // The user-defined attribute access methods defined below set 
 // and get top-level 
 // metadata attributes - attributes that may apply to the entire
 // data set. 
 //
 //------------------------------------------------------------------


 //
 vector<string> GetUserDataLongTags() const {return(_userDLTags);}

 //
 int SetUserDataLong(const string &tag, const vector<long> &value) {
    _RecordUserDataTags(_userDLTags, tag);
    _rootnode->SetElementLong(tag, value);
    return(0);
 }

 //
 vector<long> GetUserDataLong(const string &tag) const {
    return(_rootnode->GetElementLong(tag));
 }

 vector<string> GetUserDataDoubleTags() const {return(_userDDTags);}

 int SetUserDataDouble(const string &tag, const vector<double> &value) {
    _RecordUserDataTags(_userDDTags, tag);
    _rootnode->SetElementDouble(tag, value);
    return(0);
 }
 vector<double> GetUserDataDouble(const string &tag) const {
    return(_rootnode->GetElementDouble(tag));
 }

 vector<string> GetUserDataStringTags() const {return(_userDSTags);}

 int SetUserDataString(const string &tag, const string &value) {
    _RecordUserDataTags(_userDSTags, tag);
    _rootnode->SetElementString(tag, value);
    return(0);
 }
 string GetUserDataString(const string &tag) const {
    return(_rootnode->GetElementString(tag));
 }

 int SetUserDataStringVec(const string &tag, const vector <string> &value) {
    _RecordUserDataTags(_userDSTags, tag);
    _rootnode->SetElementStringVec(tag, value);
    return(0);
 }
 vector <string> GetUserDataStringVec(const string &tag) const {
    vector <string> vec;
    _rootnode->GetElementStringVec(tag, vec);
    return(vec);
 }


 //------------------------------------------------------------------
 //         Time Step User-Defined Metdata Attributes
 //
 // The user-defined attribute access methods defined below set 
 // and get time step
 // metadata attributes - attributes that may apply to a particular
 // time step
 //
 //
 //------------------------------------------------------------------

 //
 vector<string> GetTSUserDataLongTags() const {
    return(_timeStepUserDLTags); 
 }

 //
 int SetTSUserDataLong(size_t ts, const string &tag, const vector<long> &value) {
    CHK_TS_REQ(ts, -1)
    _RecordUserDataTags(_timeStepUserDLTags, tag);
    _rootnode->GetChild(ts)->SetElementLong(tag, value);
    return(0);
 }

 //
 vector<long> GetTSUserDataLong( size_t ts, const string &tag) const {
    CHK_TS_OPT(ts, _emptyLongVec)
    return(_rootnode->GetChild(ts)->GetElementLong(tag));
 }

 int SetTSUserDataDouble(
    size_t ts, const string &tag, const vector<double> &value
 ) {
    CHK_TS_REQ(ts, -1)
    _RecordUserDataTags(_timeStepUserDDTags, tag);
    _rootnode->GetChild(ts)->SetElementDouble(tag, value);
    return(0);
 }

 vector<double> GetTSUserDataDouble(size_t ts, const string &tag) const {
    CHK_TS_OPT(ts, _emptyDoubleVec)
    return(_rootnode->GetChild(ts)->GetElementDouble(tag));
 }
 vector<string> GetTSUserDataDoubleTags() const {
    return(_timeStepUserDDTags);
 }


 int SetTSUserDataString(
    size_t ts, const string &tag, const string &value
 ) {
    CHK_TS_REQ(ts, -1)
    _RecordUserDataTags(_timeStepUserDSTags, tag);
    _rootnode->GetChild(ts)->SetElementString(tag, value);
    return(0);
 }

 string GetTSUserDataString(size_t ts, const string &tag) const {
    CHK_TS_OPT(ts, _emptyString)
    return(_rootnode->GetChild(ts)->GetElementString(tag));
 }
 vector<string> GetTSUserDataStringTags() const {
    return(_timeStepUserDSTags);
 }

 //------------------------------------------------------------------
 //         Variable User-Defined Metdata Attributes
 //
 // The user-defined attribute access methods defined below set 
 // and get variable
 // metadata attributes - attributes that may apply to a particular
 // variable within a given time step.
 // Attribute get/set methods exist for attributes of type
 // vector<long>, vector<double>, and string. Addionally, for each 
 // attribute type (long, string, or double) a method is provided for 
 // retrieving the names of all attributes defined of that type.
 //
 //------------------------------------------------------------------

 // Return a list of the names of user defined variable attributes
 // of type long.
 //
 //
 vector<string> GetVUserDataLongTags() const {
    return(_variableUserDLTags); 
 }

 //
 int SetVUserDataLong(
    size_t ts, const string &var, const string &tag, const vector<long> &value
 ) {
    CHK_VAR_REQ(ts, var, -1)
    _RecordUserDataTags(_variableUserDLTags, tag);
    _rootnode->GetChild(ts)->GetChild(var)->SetElementLong(tag, value);
    return(0);
 }

 //
 vector<long> GetVUserDataLong(
    size_t ts, const string &var, const string &tag
 ) const {
    CHK_VAR_OPT(ts, var, _emptyLongVec)
    return(_rootnode->GetChild(ts)->GetChild(var)->GetElementLong(tag));
 }

 vector<string> GetVUserDataDoubleTags() const {
    return(_variableUserDDTags);
 }
 int SetVUserDataDouble(
    size_t ts, const string &var, const string &tag, const vector<double> &value
 ) {
    CHK_VAR_REQ(ts, var, -1)
    _RecordUserDataTags(_variableUserDDTags, tag);
    _rootnode->GetChild(ts)->GetChild(var)->SetElementDouble(tag, value);
    return(0);
 }

 vector<double> GetVUserDataDouble(
    size_t ts, const string &var, const string &tag
 ) const {
    CHK_VAR_OPT(ts, var, _emptyDoubleVec)
    return(_rootnode->GetChild(ts)->GetChild(var)->GetElementDouble(tag));
 }

 int SetVUserDataString(
    size_t ts, const string &var, const string &tag, const string &value
 ) {
    CHK_VAR_REQ(ts,var,-1)
    _RecordUserDataTags(_variableUserDSTags, tag);
    _rootnode->GetChild(ts)->GetChild(var)->SetElementString(tag, value);
    return(0);
 }

 string GetVUserDataString(
    size_t ts, const string &var, const string &tag
 ) const {
    CHK_VAR_OPT(ts, var, _emptyString)
    return(_rootnode->GetChild(ts)->GetChild(var)->GetElementString(tag));
 }

 vector<string> GetVUserDataStringTags() const {
    return(_variableUserDSTags);
 }

private:
 XmlNode    *_rootnode;     // root node of the xml tree
 size_t _bs[3];             // blocking factor to be used by data
 size_t _dim[3];            // data dimensions
 int    _nFilterCoef;       // Lifting filter coefficients
 int    _nLiftingCoef;
 int    _numTransforms;     // Number of wavelet transforms
 int    _msbFirst;          // Most Significant Byte First storage order
 int    _vdfVersion;        // VDF file version number
 int    _vdcType;           // VDC file type (1 or 2)
 string _wname;             // Wavelet name
 string _wmode;             // Wavelet boundary handling mode
 string _metafileDirName;   // path to metafile parent directory
 string _metafileName;      // basename of path to metafile 
 string _dataDirName;       // basename of path to data directory
 vector <size_t> _cratios;  // compression ratios

 vector <double>    _emptyDoubleVec;
 vector <long>      _emptyLongVec;
 string             _emptyString;

 
 string _currentVar;    // name of variable currently being processed
 long   _currentTS; // Number of time step currently being processed


 // Known xml tags
 //
 static const string _childrenTag;
 static const string _commentTag;
 static const string _coordSystemTypeTag;
 static const string _dataRangeTag;
 static const string _extentsTag;
 static const string _gridTypeTag;
 static const string _numTimeStepsTag;
 static const string _basePathTag;
 static const string _auxBasePathTag;
 static const string _rootTag;
 static const string _userTimeTag;
 static const string _userTimeStampTag;
 static const string _timeStepTag;
 static const string _varNamesTag;
 static const string _vars3DTag;
 static const string _vars2DXYTag;
 static const string _vars2DXZTag;
 static const string _vars2DYZTag;
 static const string _coordVarsTag;
 static const string _xCoordsTag;
 static const string _yCoordsTag;
 static const string _zCoordsTag;
 static const string _periodicBoundaryTag;
 static const string _gridPermutationTag;
 static const string _mapProjectionTag;
 static const string _missingValueTag;

 // known xml attribute names
 //
 static const string _blockSizeAttr;
 static const string _dimensionLengthAttr;
 static const string _numTransformsAttr;
 static const string _filterCoefficientsAttr;
 static const string _liftingCoefficientsAttr;
 static const string _msbFirstAttr;
 static const string _vdfVersionAttr;
 static const string _numChildrenAttr;
 static const string _waveletNameAttr;
 static const string _waveletBoundaryModeAttr;
 static const string _vdcTypeAttr;
 static const string _cRatiosAttr;
 

 // Names of tags for user-defined data of type long, double, or string
 //
 vector <string> _userDLTags;   // top-level long tags
 vector <string> _userDDTags;
 vector <string> _userDSTags;

 vector <string> _timeStepUserDLTags;   // time step long tags
 vector <string> _timeStepUserDDTags;
 vector <string> _timeStepUserDSTags;

 vector <string> _variableUserDLTags;   // variable long tags
 vector <string> _variableUserDDTags;
 vector <string> _variableUserDSTags;

 string _newMapProjection;

 int _init();
 int _init1(
    const size_t dim[3], size_t numTransforms, const size_t bs[3],
    int nFilterCoef = 1, int nLiftingCoef = 1, int msbFirst = 1,
    int vdfVersion = VDF_VERSION
 );
 int _init2(
    const size_t dim[3], const size_t bs[3], const vector <size_t> &cratios,
    string wname, string wmode, int vdfVersion = VDF_VERSION
 );

 int _SetNumTimeSteps(long value);
 int _setVariableTypes(
    const string &tag,
    const vector <string> &value,
    const vector <string> &delete_tags
 );
 int _SetVariables(XmlNode *node, long ts);
 int _SetVariableNames(
    string set_tag,
    const vector <string> &delete_tags,
    const vector <string> &value
 ); 

 int _RecordUserDataTags(vector <string> &keys, const string &tag);

bool elementStartHandler(ExpatParseMgr*, int depth , std::string& tag, const char **attr);
bool elementEndHandler(ExpatParseMgr*, int depth , std::string& );

 // XML Expat element handler helps. A different handler is defined
 // for each possible state (depth of XML tree) from 0 to 3
 //
 void _startElementHandler0(ExpatParseMgr*,const string &tag, const char **attrs);
 void _startElementHandler1(ExpatParseMgr*,const string &tag, const char **attrs);
 void _startElementHandler2(ExpatParseMgr*,const string &tag, const char **attrs);
 void _startElementHandler3(ExpatParseMgr*,const string &tag, const char **attrs);
 void _endElementHandler0(ExpatParseMgr*,const string &tag);
 void _endElementHandler1(ExpatParseMgr*,const string &tag);
 void _endElementHandler2(ExpatParseMgr*,const string &tag);
 void _endElementHandler3(ExpatParseMgr*,const string &tag);
 virtual int SetDefaults(); // Set some defaults 


};


};

#endif  //  _MetadataVDC_h_