DataMgr.h

Go to the documentation of this file.

//
//      $Id$
//

#ifndef _DataMgr_h_
#define _DataMgr_h_

#include <list>
#include <map>
#include <string>
#include <vector>
#include <iostream>
#include <vapor/MyBase.h>
#include <vapor/BlkMemMgr.h>
#include <vapor/common.h>
#include <vapor/RegularGrid.h>
#include <vapor/LayeredGrid.h>
#include <vapor/SphericalGrid.h>
#include <vapor/StretchedGrid.h>

namespace VAPoR {
class PipeLine;

//

//
class VDF_API DataMgr : public VetsUtil::MyBase {

public:

 enum VarType_T {
    VARUNKNOWN = -1,
    VAR3D, VAR2D_XY, VAR2D_XZ, VAR2D_YZ
 };

 //
 DataMgr(
    size_t mem_size
 );

 virtual ~DataMgr(); 

 //
 virtual void   GetDim(size_t dim[3], int reflevel = 0) const {
    return(_GetDim(dim, reflevel));
 }

 //
 int GetNumTransforms() const { return(_GetNumTransforms()); };

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

 //
 virtual string GetCoordSystemType() const {
    return(_GetCoordSystemType());
 }

 //
 virtual string GetGridType() const { return(_GetGridType()); };

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

 //
 virtual long GetNumTimeSteps() const { return(_GetNumTimeSteps()); };


 //
 virtual string GetMapProjection() const {
    return(_GetMapProjection()); 
 }

 virtual vector <string> GetVariableNames() const;

 //
 virtual vector <string> GetVariables3D() const;

 //
 virtual vector <string> GetVariables2DXY() const;

 //
 virtual vector <string> GetVariables2DXZ() const;

 //
 virtual vector <string> GetVariables2DYZ() const;

 //
 virtual vector <string> GetCoordinateVariables() const {
    return(_GetCoordinateVariables());
 };

 //
 virtual vector<long> GetPeriodicBoundary() const {
    return(_GetPeriodicBoundary());
 };

 //
 virtual vector<long> GetGridPermutation() const {
    return(_GetGridPermutation());
 };

 //
 virtual double GetTSUserTime(size_t ts) const {
    return(_GetTSUserTime(ts));
 };

 //
 virtual void GetTSUserTimeStamp(size_t ts, string &s) const {
    return(_GetTSUserTimeStamp(ts, s));
 };

 //
virtual RegularGrid   *GetGrid(
    size_t ts,
    string varname,
    int reflevel,
    int lod,
    const size_t min[3],
    const size_t max[3],
    bool lock = false
 );

 //
 void UnlockGrid(const RegularGrid *rg);

 //
 int UnlockRegion(const float *) {return(-1);};

 //
 void   Clear();

 //
 int GetDataRange(
    size_t ts, const char *varname, float range[2],
    int reflevel = 0, int lod = 0
 );

 //
 int GetValidRegion(
    size_t ts,
    const char *varname,
    int reflevel,
    size_t min[3],
    size_t max[3]
 );


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

 bool BestMatch(
    size_t ts, const char *varname, int req_reflevel, int req_lod,
    int &reflevel, int &lod
 );


 int NewPipeline(PipeLine *pipeline);

 void RemovePipeline(string name);

 //
 bool IsVariableDerived(string varname) const;

 //
 bool IsVariableNative(string varname) const;

 virtual VarType_T GetVarType(const string &varname) const; 

 bool GetMissingValue(string varname, float &value) const;


    
 void PurgeVariable(string varname);

 //
 virtual void   MapUserToVox(
    size_t timestep,
    const double vcoord0[3], size_t vcoord1[3], int reflevel = 0, int lod = 0
 );

 //
 virtual void   MapVoxToUser(
    size_t timestep,
    const size_t vcoord0[3], double vcoord1[3], int ref_level = 0, int lod=0
 );

 virtual void    GetEnclosingRegion(
    size_t ts, const double minu[3], const double maxu[3],
    size_t min[3], size_t max[3],
    int reflevel = 0, int lod = 0
 );

 //
 virtual bool IsCoordinateVariable(string varname) const;

 void PrintCache(std::ostream &o);

 void SetInterpolationOrder(int order) {_interpolationOrder = order;}

 int GetInterpolationOrder() const {return(_interpolationOrder); }

protected:


 const vector<string> emptyVec;

 // The protected methods below are pure virtual and must be implemented by any 
 // child class  of the DataMgr.

 //
 virtual void   _GetDim(size_t dim[3], int reflevel = 0) const = 0;


 //
 virtual void _GetBlockSize(size_t bs[3], int reflevel) const = 0;

 //
 virtual int _GetNumTransforms() const = 0;

 //
 virtual vector <size_t> _GetCRatios() const {
    vector <size_t> cr; cr.push_back(1); return(cr);
 }

 //
 virtual string _GetCoordSystemType() const { return("cartesian"); };

 //
 virtual string _GetGridType() const { return("regular"); };

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

 //
 virtual vector <double> _GetTSXCoords(size_t ts) const {
    vector <double> empty; return(empty);
 }

 virtual vector <double> _GetTSYCoords(size_t ts) const {
    vector <double> empty; return(empty);
 }

 virtual vector <double> _GetTSZCoords(size_t ts) const {
    vector <double> empty; return(empty);
 }

 //
 virtual long _GetNumTimeSteps() const = 0;


 //
 virtual string _GetMapProjection() const {string empty; return (empty); };

 //
 virtual vector <string> _GetVariables3D() const = 0;

 //
 virtual vector <string> _GetVariables2DXY() const = 0;

 //
 virtual vector <string> _GetVariables2DXZ() const = 0;

 //
 virtual vector <string> _GetVariables2DYZ() const = 0;

 //
 virtual vector <string> _GetCoordinateVariables() const { 
    vector <string> v;
    v.push_back("NONE"); v.push_back("NONE"); v.push_back("ELEVATION");
    return(v);
 }


 //
 virtual vector<long> _GetPeriodicBoundary() const = 0;


 virtual vector<long> _GetGridPermutation() const {
    vector <long> v; v.push_back(0); v.push_back(1); v.push_back(2); return(v);
 };

 //
 virtual double _GetTSUserTime(size_t ts) const = 0;


 //
 virtual void _GetTSUserTimeStamp(size_t ts, string &s) const = 0;


 //
 virtual int _VariableExists(
    size_t ts,
    const char *varname,
    int reflevel = 0,
    int lod = 0
 ) const = 0;


 virtual int    _OpenVariableRead(
    size_t timestep,
    const char *varname,
    int reflevel = 0,
    int lod = 0
 ) = 0;

 //
 virtual void _GetValidRegion(
    size_t min[3], size_t max[3], int reflevel
 ) const = 0;

 virtual const float *_GetDataRange() const { return(NULL);};

 //
 virtual bool _GetMissingValue(string varname, float &value) const {
    return(false); 
 };


 //
 virtual int    _BlockReadRegion(
    const size_t bmin[3], const size_t bmax[3],
    float *region
 ) = 0;

 //
 virtual int    _CloseVariable() = 0;

private:
 int _interpolationOrder;

 size_t _mem_size;

 typedef struct {
    size_t ts;
    string varname;
    int reflevel;
    int lod;
    size_t min[3];
    size_t max[3];
    int lock_counter;
    float *blks;
 } region_t;

 // a list of all allocated regions
 list <region_t> _regionsList;

 BlkMemMgr  *_blk_mem_mgr;

 vector <PipeLine *> _PipeLines;


 //
 // Cache for various metadata attributes 
 //
 class VarInfoCache  {
 public:

    //
    // min and max variable value range
    //
    bool GetRange(
        size_t ts, string varname, int ref, int lod, float range[2]
    ) const;
    void SetRange(
        size_t ts, string varname, int ref, int lod, const float range[2]
    );
    void PurgeRange(
        size_t ts, string varname, int ref, int lod
    );

    //
    // min and max region extents
    //
    bool GetRegion(
        size_t ts, string varname, int ref, size_t min[3], size_t max[3]
    ) const;
    void SetRegion(
        size_t ts, string varname, int ref, const size_t min[3], 
        const size_t max[3]
    );
    void PurgeRegion(
        size_t ts, string varname, int ref
    );

    //
    // does the variable exist?
    //
    bool GetExist(
        size_t ts, string varname, int ref, int lod, bool &exist
    ) const;
    void SetExist(size_t ts, string varname, int ref, int lod, bool exist);
    void PurgeExist(size_t ts, string varname, int ref, int lod);

    void PurgeVariable(string varname);
    void Clear() {_cache.clear(); }



 private:

    class var_info {
    public:
        map <size_t, bool> exist;
        map <size_t, vector <size_t> > region;
        map <size_t, vector <float> > range;
    };

    var_info *get_var_info(size_t ts, string varname) const;

    map <size_t, map <string, var_info> > _cache;
 };

 VarInfoCache _VarInfoCache;
 std::map <size_t, vector <double> > _extentsCache;

 float  *get_region_from_cache(
    size_t ts,
    string varname,
    int reflevel,
    int lod,
    const size_t min[3],
    const size_t max[3],
    bool lock
 );

 float  *get_region_from_fs(
    size_t ts,
    string varname,
    int reflevel,
    int lod,
    const size_t min[3],
    const size_t max[3],
    bool lock
 );

 float *get_region(
    size_t ts, string varname, int reflevel, int lod, 
    const size_t min[3], const size_t max[3], bool lock, bool *ondisk
 );

 void unlock_blocks(const float *blks);

 float    *alloc_region(
    size_t ts,
    const char *varname,
    VarType_T vtype,
    int reflevel,
    int lod,
    const size_t min[3],
    const size_t max[3],
    bool lock,
    bool fill
 ); 

 void   free_region(
    size_t ts,
    string varname,
    int reflevel,
    int lod,
    const size_t min[3],
    const size_t max[3]
 );

 void   free_var(const string &, int do_native);

 int    free_lru();

 int    _DataMgr(size_t mem_size);

 RegularGrid *execute_pipeline(
    size_t ts, string varname, int reflevel, int lod,
    const size_t min[3], const size_t max[3], bool lock,
    float *xcblks, float *ycblks, float *zcblks
 ); 

 // Check for circular dependencies in a pipeline 
 //
 bool cycle_check(
    const map <string, vector <string> > &graph,
    const string &node,
    const vector <string> &depends
 ) const;

 // Return true if the inputs of a require the outputs of b
 //
 bool depends_on(
    const PipeLine *a, const PipeLine *b
 ) const;

 vector <string> get_native_variables() const;
 vector <string> get_derived_variables() const;

 PipeLine *get_pipeline_for_var(string varname) const;

 void coord_array(
    const vector <double> &xin, vector <double> &xout, size_t ldelta
 ) const;

 void map_vox_to_user_regular(
    size_t timestep, const size_t vcoord0[3], double vcoord1[3], int reflevel
 ) const;

 void map_vox_to_blk(
    const size_t vcoord[3], size_t bcoord[3], int reflevel = -1
 ) const;

 void get_dim_blk( size_t bdim[3], int reflevel) const;

 RegularGrid *make_grid(
    size_t ts, string varname, int reflevel, int lod,
    const size_t bmin[3], const size_t bmax[3],
    float *blocks, float *xcblocks, float *ycblocks, float *zcblocks
 );





};

class VDF_API PipeLine {
    public:

    PipeLine(
        string name,
        vector <string> inputs, 
        vector <pair <string, DataMgr::VarType_T> > outputs
    ) {
        _name = name;
        _inputs = inputs;
        _outputs = outputs;
    }
    virtual ~PipeLine(){
    }

    //
    virtual int Calculate (
        vector <const RegularGrid *> input_grids,
        vector <RegularGrid *> output_grids,    // space for the output variables
        size_t ts, // current time step
        int reflevel, // refinement level
        int lod //
    ) = 0;

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

    //
    const vector <string> &GetInputs() const {return (_inputs); };

    //
    const vector <pair <string, DataMgr::VarType_T> > &GetOutputs() const { 
        return (_outputs); 
    };


private:
    string _name;
    vector <string> _inputs;
    vector<pair<string, DataMgr::VarType_T> > _outputs;
};


};

#endif  //  _DataMgr_h_