VDCNetCDF.h

Go to the documentation of this file.

#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
#include "vapor/VDC.h"
#include "vapor/WASP.h"

#ifndef _VDCNetCDF_H_
#define _VDCNetCDF_H_

namespace VAPoR {

class VDF_API VDCNetCDF : public VAPoR::VDC {
public:

 //
 VDCNetCDF(
    int numthreads = 0,
    size_t master_theshold=10*1024*1024, 
    size_t variable_threshold=100*1024*1024
 );
 virtual ~VDCNetCDF();

 //
 static string GetDataDir(string path);

 virtual int GetPath(
    string varname, size_t ts, string &path, size_t &file_ts,
    size_t &max_ts
 ) const;

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

 //
 static bool DataDirExists(string path) ;


 //
 virtual int Initialize(
    const vector <string> &paths, AccessMode mode, size_t chunksizehint = 0
 );
 virtual int Initialize(
    string path, AccessMode mode, size_t chunksizehint = 0
 ) {
    std::vector <string> paths;
    paths.push_back(path);
    return(Initialize(paths, mode, chunksizehint));
 }

 //
 size_t GetMasterThreshold() const {return _master_threshold; };

 //
 size_t GetVariableThreshold() const {return _variable_threshold; };

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

 //
 int CloseVariable();


 //
 int OpenVariableWrite(size_t ts, string varname, int lod=-1);

 //
 int Write(const float *region);

 int WriteSlice(const float *slice);

 //
 int Read(float *region);

 //
 int ReadSlice(float *slice);

 //
 int ReadRegion(
    const std::vector<size_t> &min, 
    const std::vector<size_t> &max, float *region
 );

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

 //
 int PutVar(string varname, int lod, const float *data);

 //
 int PutVar(size_t ts, string varname, int lod, const float *data);

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

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


 //
 bool CompressionInfo(
    std::vector <size_t> bs, string wname, size_t &nlevels, size_t &maxcratio
 ) const;

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



protected:

#ifndef DOXYGEN_SKIP_THIS
 virtual int _WriteMasterMeta();
 virtual int _ReadMasterMeta();
#endif

private:
 int _version;
 WASP *_master; // Master NetCDF file

 class open_file_info {
 public:
   open_file_info() {
    _wasp = NULL;
    _write = false;
    _slice_num = 0;
    _ts = 0;
    _file_ts = 0;
    _varname.clear();
    _level = 0;
   };
   open_file_info(
    WASP *wasp, bool write, BaseVar var, size_t slice_num,
    size_t ts, size_t file_ts, string varname, int level
   ) :
    _wasp(wasp),
    _write(write),
    _var(var),
    _slice_num(slice_num),
    _ts(ts),
    _file_ts(file_ts),
    _varname(varname),
    _level(level)
  { };
     
   WASP *_wasp; // Currently opened data file
   bool _write; // opened for writing?
   BaseVar _var;
   size_t _slice_num; // index of current slice for WriteSlice, ReadSlice
   size_t _ts;  // global time step of current open variable
   size_t _file_ts; // local (within file) time step of current open var
   string _varname; // name of current open variable
   int _level;
 };
 open_file_info _ofi;   // currently open data or coordinate variable
 open_file_info _ofimask;   // current opened mask variable
 
 VetsUtil::SmartBuf _sb_slice_buffer;
 VetsUtil::SmartBuf _mask_buffer;
 float *_slice_buffer;
 
 size_t _chunksizehint; // NetCDF chunk size hint for file creates
 size_t _master_threshold;
 size_t _variable_threshold;
 int _nthreads;

 int _WriteMasterDimensions();
 int _WriteMasterAttributes (
    string prefix, const map <string, Attribute> &atts
 ); 
 int _WriteMasterAttributes ();
 int _WriteMasterBaseVarDefs(string prefix, const BaseVar &var); 
 int _WriteMasterCoordVarsDefs(); 
 int _WriteMasterDataVarsDefs(); 
 int _WriteSlice(WASP *file, const float *slice);
 int _WriteSlice(NetCDFCpp *file, const float *slice);

 int _ReadMasterDimensions();
 int _ReadMasterAttributes (
    string prefix, map <string, Attribute> &atts
 ); 
 int _ReadMasterAttributes ();
 int _ReadMasterBaseVarDefs(string prefix, BaseVar &var); 
 int _ReadMasterCoordVarsDefs(); 
 int _ReadMasterDataVarsDefs(); 
 int _ReadSlice(WASP *file, float *slice);
 int _ReadSlice(NetCDFCpp *file, float *slice);

 int _PutAtt(
    WASP *ncdf,
    string varname,
    string tag,
    const Attribute &attr
 );

 int _DefBaseVar(WASP *ncdf, const VDC::BaseVar &var, size_t max_ts);
 int _DefDataVar(WASP *ncdf, const VDC::DataVar &var, size_t max_ts);
 int _DefCoordVar(WASP *ncdf, const VDC::CoordVar &var, size_t max_ts);

 bool _var_in_master(const VDC::BaseVar &var) const;

 string _get_mask_varname(string varname) const;

 unsigned char *_read_mask_var(
    vector <size_t> start, vector <size_t> count
 );

 WASP *_OpenVariableRead(
    size_t ts, const VDC::BaseVar &var, int clevel, int lod,
    size_t &file_ts
 );



};
};

#endif