DataMgrV3_0.h

Go to the documentation of this file.

#include <vector>
#include <iostream>
#include <list>
#include <vapor/BlkMemMgr.h>
#include <vapor/DC.h>
#include <vapor/MyBase.h>
#include <vapor/RegularGrid.h>
#include <vapor/LayeredGrid.h>

#ifndef DataMgvV3_0_h
#define DataMgvV3_0_h

using namespace std;

namespace VAPoR {
class PipeLine;

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

 //
 DataMgrV3_0(string format, size_t mem_size, int nthreads = 0);

 virtual ~DataMgrV3_0();

 //
 virtual int Initialize(const std::vector <string> &files);


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

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

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

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

 void GetTimeCoordinates(std::vector <double> &timecoords) const {
    timecoords = _timeCoordinates;
 };


 bool GetDataVarInfo( string varname, VAPoR::DC::DataVar &datavar) const;

 //
 bool GetBaseVarInfo(string varname, VAPoR::DC::BaseVar &var) const;

 bool GetCoordVarInfo(string varname, VAPoR::DC::CoordVar &cvar) const;

 bool IsTimeVarying(string varname) const;

 //
 bool IsCompressed(string varname) const;

 //
 int GetNumTimeSteps(string varname) const;

 //
 int GetNumRefLevels(string varname) const;

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

 //
 VAPoR::RegularGrid *GetVariable (
    size_t ts, string varname, int level, int lod, bool lock=false
 );

 VAPoR::RegularGrid *GetVariable (
    size_t ts, string varname, int level, int lod, 
    std::vector <double> min, std::vector <double> max, bool lock=false
 );

 VAPoR::RegularGrid *GetVariable(
    size_t ts, string varname, int level, int lod,
    std::vector <size_t> min, std::vector <size_t> max, bool lock=false
 );

 int GetVariableExtents(
    size_t ts, string varname, int level,
    std::vector <double> &min , std::vector <double> &max
 );

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

 //
 void UnlockGrid(const VAPoR::RegularGrid *rg);

 //
 void   Clear();

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

#ifdef  DEAD

 int NewPipeline(PipeLine *pipeline);

 void RemovePipeline(string name);
#endif

 //
 bool IsVariableDerived(string varname) const;

 //
 bool IsVariableNative(string varname) const;

    
 void PurgeVariable(string varname);

 virtual string GetMapProjection() const {return(""); };

 class BlkExts {
 public:
  BlkExts();
  BlkExts(const std::vector <size_t> &bmin, const std::vector <size_t> &bmax);

  void Insert(
    const std::vector <size_t> &bcoord, 
    const std::vector <double> &min, 
    const std::vector <double> &max 
  );

  bool Intersect(
    const std::vector <double> &min, 
    const std::vector <double> &max,
    std::vector <size_t> &bmin,
    std::vector <size_t> &bmax
  ) const;

  friend std::ostream &operator<<(
    std::ostream &o, const BlkExts &b
  );

 private:

    std::vector <size_t> _bmin;
    std::vector <size_t> _bmax;
    std::vector < std::vector < double > > _mins;
    std::vector < std::vector < double > > _maxs;
 };
private:

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

    //
    //
    void Set(
        size_t ts, std::vector <string> varnames, int level, int lod, string key,
        const std::vector <size_t> &values
    );
    void Set(
        size_t ts, string varname, int level, int lod, string key,
        const std::vector <size_t> &values
    ) { 
        std::vector <string> varnames;
        varnames.push_back(varname);
        Set(ts, varnames, level, lod, key, values);
    }

    bool Get(
        size_t ts, std::vector <string> varnames, int level, int lod, string key,
        std::vector <size_t> &values
    ) const;

    bool Get(
        size_t ts, string varname, int level, int lod, string key,
        std::vector <size_t> &values
    ) const { 
        std::vector <string> varnames;
        varnames.push_back(varname);
        return Get(ts, varnames, level, lod, key, values);
    }

    void PurgeSize_t(
        size_t ts, std::vector <string> varnames, int level, int lod, string key
    ); 
    void PurgeSize_t(
        size_t ts, string varname, int level, int lod, string key
    ) {
        std::vector <string> varnames;
        varnames.push_back(varname);
        PurgeSize_t(ts, varnames, level, lod, key);
    } 

    void Set(
        size_t ts, std::vector <string> varnames, int level, int lod, string key,
        const std::vector <double> &values
    );
    void Set(
        size_t ts, string varname, int level, int lod, string key,
        const std::vector <double> &values
    ) { 
        std::vector <string> varnames;
        varnames.push_back(varname);
        Set(ts, varnames, level, lod, key, values);
    }

    bool Get(
        size_t ts, std::vector <string> varnames, int level, int lod, string key,
        std::vector <double> &values
    ) const;

    bool Get(
        size_t ts, string varname, int level, int lod, string key,
        std::vector <double> &values
    ) const { 
        std::vector <string> varnames;
        varnames.push_back(varname);
        return Get(ts, varnames, level, lod, key, values);
    }

    void PurgeDouble(
        size_t ts, std::vector <string> varnames, int level, int lod, string key
    ); 
    void PurgeDouble(
        size_t ts, string varname, int level, int lod, string key
    ) {
        std::vector <string> varnames;
        varnames.push_back(varname);
        PurgeDouble(ts, varnames, level, lod, key);
    } 

    void Clear() {
        _cacheSize_t.clear(); 
        _cacheDouble.clear(); 
    }

  static string _make_hash(
    string key, size_t ts, std::vector <string> cvars, int level, int lod
  );

 private:

  std::map <string, std::vector <size_t> > _cacheSize_t;
  std::map <string, std::vector <double> > _cacheDouble;


 };

 string _format;
 int _nthreads;
 size_t _mem_size;

 DC *_dc;

 std::vector <double> _timeCoordinates;

 typedef struct {
    size_t ts;
    string varname;
    int level;
    int lod;
    std::vector <size_t> bmin;
    std::vector <size_t> bmax;
    int lock_counter;
    float *blks;
 } region_t;

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

 VAPoR::BlkMemMgr  *_blk_mem_mgr;


 std::vector <PipeLine *> _PipeLines;


 VarInfoCache _varInfoCache;
 std::map <string, BlkExts> _blkExtsCache;

 int _get_coord_vars(
    string varname, std::vector <string> &scvars, string &tcvar
 ) const;

 int _get_time_coordinates(std::vector <double> &timecoords);

 VAPoR::RegularGrid *_make_grid_regular(
    const VAPoR::DC::DataVar &var,
    const std::vector <size_t> &min,
    const std::vector <size_t> &max,
    const std::vector <size_t> &dims,
    const std::vector <float *> &blkvec,
    const std::vector <size_t> &bs,
    const std::vector <size_t> &bmin,
    const std::vector <size_t> &bmax
 ) const;

 VAPoR::LayeredGrid *_make_grid_layered(
    const VAPoR::DC::DataVar &var,
    const std::vector <size_t> &min,
    const std::vector <size_t> &max,
    const std::vector <size_t> &dims,
    const std::vector <float *> &blkvec,
    const std::vector <size_t> &bs,
    const std::vector <size_t> &bmin,
    const std::vector <size_t> &bmax
 ) const;

 VAPoR::RegularGrid *_make_grid(
    const VAPoR::DC::DataVar &var,
    const std::vector <size_t> &min,
    const std::vector <size_t> &max,
    const std::vector <size_t> &dims,
    const std::vector <float *> &blkvec,
    const std::vector < std::vector <size_t > > &bsvec,
    const std::vector < std::vector <size_t > > &bminvec,
    const std::vector < std::vector <size_t > > &bmaxvec
 ) const;

 int _find_bounding_grid(
    size_t ts, string varname, int level, int lod,
    std::vector <double> min, std::vector <double> max,
    std::vector <size_t> &min_ui, std::vector <size_t> &max_ui
 );

int _setupCoordVecs(
    size_t ts,
    string varname,
    int level,
    int lod,
    const vector <size_t> &min,
    const vector <size_t> &max,
    vector <string> &varnames,
    vector < vector <size_t > > &dimsvec,
    vector < vector <size_t > > &dims_at_levelvec,
    vector < vector <size_t > > &bsvec,
    vector < vector <size_t > > &bs_at_levelvec,
    vector < vector <size_t > > &bminvec,
    vector < vector <size_t > > &bmaxvec
 ) const;

 VAPoR::RegularGrid *_getVariable(
    size_t ts,
    string varname,
    int level,
    int lod,
    bool    lock,
    bool    dataless
 ); 

 VAPoR::RegularGrid *_getVariable(
    size_t ts,
    string varname,
    int level,
    int lod,
    std::vector <size_t> min,
    std::vector <size_t> max,
    bool    lock,
    bool    dataless
 ); 

 float   *_get_region_from_cache(
    size_t ts,
    string varname,
    int level,
    int lod,
    const std::vector <size_t> &bmin,
    const std::vector <size_t> &bmax,
    bool    lock
 );

 float *_get_region_from_fs(
    size_t ts, string varname, int level, int lod,
    const std::vector <size_t> &bs, const std::vector <size_t> &bmin,
    const std::vector <size_t> &bmax, bool lock
 );

 float *_get_region(
    size_t ts,
    string varname,
    int level,
    int nlevels,
    int lod,
    int nlods,
    const std::vector <size_t> &bs,
    const std::vector <size_t> &bmin,
    const std::vector <size_t> &bmax,
    bool lock
 );
 int _get_regions(
    size_t ts,
    const std::vector <string> &varnames,
    int level, int lod,
    bool lock,
    const std::vector < std::vector <size_t > > &bsvec,
    const std::vector < std::vector <size_t> > &bminvec,
    const std::vector < std::vector <size_t> > &bmaxvec,
    std::vector <float *> &blkvec
 ); 

 void _unlock_blocks(const float *blks);

 std::vector <string> _get_native_variables() const;
 std::vector <string> _get_derived_variables() const;

 float   *_alloc_region(
    size_t ts,
    string varname,
    int level,
    int lod,
    std::vector <size_t> bmin,
    std::vector <size_t> bmax,
    std::vector <size_t> bs,
    int element_sz,
    bool    lock,
    bool fill
 ); 

 void    _free_region(
    size_t ts,
    string varname,
    int level,
    int lod,
    std::vector <size_t> bmin,
    std::vector <size_t> bmax
 );

 bool _free_lru();
 void _free_var(string varname);

 int _level_correction(string varname, int &level) const;
 int _lod_correction(string varname, int &lod) const;

};

};
#endif