NetCDFCollection.h

Go to the documentation of this file.

//
// $Id: NetCDFCollection.h,v 1.7 2013/05/16 21:39:38 clynejp Exp $
//


#ifndef _NetCDFCollection_h_
#define _NetCDFCollection_h_

#include <vector>
#include <map>

#include <sstream>
#include <vapor/MyBase.h>
#include <vapor/NetCDFSimple.h>

namespace VAPoR {

//


class VDF_API NetCDFCollection : public VetsUtil::MyBase {
public:
 
 NetCDFCollection();
 virtual ~NetCDFCollection();

 virtual int Initialize(
    const std::vector <string> &files, 
    const std::vector <string> &time_dimnames, 
    const std::vector <string> &time_coordvar
 );

 //
 virtual bool VariableExists(string varname) const;

 //
 virtual bool VariableExists(size_t ts, string varname) const;

 virtual bool IsDerivedVar(string varname) const {
    return(_derivedVarsMap.find(varname) != _derivedVarsMap.end());
 }


    
 virtual bool IsStaggeredVar(string varname) const;

 virtual bool IsStaggeredDim(string dimname) const;

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

 virtual std::vector <size_t>  GetSpatialDims(string varname) const;

 virtual std::vector <string>  GetSpatialDimNames(string varname) const;

 virtual size_t  GetTimeDim(string varname) const;

 virtual string  GetTimeDimName(string varname) const;

 virtual std::vector <size_t>  GetDims(string varname) const ;

 virtual std::vector <string>  GetDimNames(string varname) const;

 //
 virtual bool IsTimeVarying(string varname) const;

 int GetXType(string varname) const;

 //
 std::vector <string> GetAttNames(string varname) const;

 int GetAttType(string varname, string attname) const;

 //
 void GetAtt(string varname, string attname, std::vector <double> &values) const;
 void GetAtt(string varname, string attname, std::vector <long> &values) const;
 void GetAtt(string varname, string attname, string &values) const;




 //
 virtual std::vector <string>  GetDimNames() const {return (_dimNames); };

 //
 virtual std::vector <size_t>  GetDims() const {return (_dimLens); };

 //
 virtual size_t GetNumTimeSteps() const {return (_times.size());}

 //
 virtual size_t GetNumTimeSteps(string varname) const {
    return(NetCDFCollection::GetTimeDim(varname));
 }



 //
 virtual int GetTime(size_t ts, double &time) const; 

 //
 virtual int GetTimes(string varname, std::vector <double> &times) const;

 //
 virtual std::vector <double> GetTimes() const {return (_times); };

 //
 virtual int GetFile(
    size_t ts, string varname, string &file, size_t &local_ts
 ) const;

 virtual int GetVariableInfo(
    string varname, NetCDFSimple::Variable &varinfo
 ) const;


 virtual bool GetMissingValue(string varname, double &mv) const;

 virtual int OpenRead(size_t ts, string varname);

 virtual int Read(size_t start[], size_t count[], float *data, int fd=0);
 virtual int Read(size_t start[], size_t count[], int *data, int fd=0);
 virtual int Read(
    std::vector <size_t> start, std::vector <size_t> count, float *data, int fd=0);
 virtual int Read(
    std::vector <size_t> start, std::vector <size_t> count, int *data, int fd=0
 );

 virtual int Read(float *data, int fd=0);
 virtual int Read(char *data, int fd=0);

 virtual int ReadNative(size_t start[], size_t count[], float *data, int fd=0);
 virtual int ReadNative(size_t start[], size_t count[], int *data, int fd=0);
 virtual int ReadNative(size_t start[], size_t count[], char *data, int fd=0);

 virtual int ReadNative(float *data, int fd=0);
 virtual int ReadNative(int *data, int fd=0);

 //
 virtual int ReadSlice(float *data, int fd=0);

 //
 virtual int ReadSliceNative(float *data, int fd=0);

 //
 virtual int SeekSlice(int offset, int whence, int fd=0);

 //
 virtual int Close(int fd=0);

 //
 virtual void SetStaggeredDims(const std::vector <string> dimnames) {
    _staggeredDims = dimnames;
 }

 //
 virtual void SetMissingValueAttName(string attname) {
    _missingValAttName = attname;
 }

 virtual std::vector <string> GetFailedVars() const {return(_failedVars); };

 friend std::ostream &operator<<(
    std::ostream &o, const NetCDFCollection &ncdfc
 );

 class TimeVaryingVar {
 public:
  TimeVaryingVar();
  int Insert(
    const NetCDFSimple *netcdf,
    const NetCDFSimple::Variable &variable, string file, 
    const std::vector <string> &time_dimnames, 
    const std::map <string, std::vector <double> > &timesmap,
    int file_org
  );
  std::vector <size_t> GetSpatialDims() const {return(_spatial_dims); };
  std::vector <string> GetSpatialDimNames() const {return(_spatial_dim_names); };
  string GetName() const {return(_name); };

  size_t GetNumTimeSteps() const {return(_time_varying ? _tvmaps.size() : 0); };
  string GetTimeDimName() const {return (_time_name); };
  int GetTime(size_t ts, double &time) const; 
  std::vector <double> GetTimes() const; 
  int GetTimeStep(double time, size_t &ts) const;
  size_t GetLocalTimeStep(size_t ts) const; 
  int GetFile(size_t ts, string &file) const;
  void GetVariableInfo(NetCDFSimple::Variable &variable) const {
    variable = _variable;
  }
  bool GetTimeVarying() const {return (_time_varying); };
  bool GetMissingValue(string attname, double &mv) const;

  friend std::ostream &operator<<(std::ostream &o, const TimeVaryingVar &var);


  typedef struct {
    int _fileidx;       // Index into _files
    double _time;       // user time for this time step
    size_t _local_ts;   // time step offset within file
  } tvmap_t;
 private:
  NetCDFSimple::Variable _variable;
  std::vector <string> _files;
  std::vector <tvmap_t> _tvmaps;
  std::vector <size_t> _spatial_dims;   // **spatial** dimensions
  std::vector <string> _spatial_dim_names;
  string _time_name;    // name of time dimension
  string _name;         // variable name
  bool _time_varying;   // true if variable's slowest varying dimension
                        // is a time dimension.
  friend bool tvmap_cmp(
    NetCDFCollection::TimeVaryingVar::tvmap_t a,
    NetCDFCollection::TimeVaryingVar::tvmap_t b);

 };

 class DerivedVar {
 public:
  DerivedVar(
    NetCDFCollection *ncdfc
  ) {
    _ncdfc = ncdfc;
  };
  virtual ~DerivedVar() {};
  virtual int Open(size_t ts) = 0;
  virtual int ReadSlice(float *slice, int fd) = 0;
  virtual int Read(float *buf, int fd) = 0;
  virtual int SeekSlice(int offset, int whence, int fd) = 0;
  virtual int Close(int fd) { return(0); };
  virtual bool TimeVarying() const = 0;
  virtual std::vector <size_t>  GetSpatialDims() const = 0;
  virtual std::vector <string>  GetSpatialDimNames() const = 0;
  virtual size_t  GetTimeDim() const = 0;
  virtual string  GetTimeDimName() const = 0;
  virtual bool GetMissingValue(double &mv) const = 0;
  virtual size_t  GetNumTimeSteps() const {return(GetTimeDim());}
 protected:
  NetCDFCollection *_ncdfc;
 };

 void InstallDerivedVar(string varname, DerivedVar *derivedVar) {
    _derivedVarsMap[varname] = derivedVar;
 };

 void RemoveDerivedVar(string varname) {
    std::map <string,DerivedVar*>::iterator itr = _derivedVarsMap.find(varname);
    if (itr != _derivedVarsMap.end()) {
        _derivedVarsMap.erase(varname);
    }
 };

protected:

 bool _GetVariableInfo(
    string varname, NetCDFSimple::Variable &variable
 ) const;

private:

 std::map <string, TimeVaryingVar > _variableList;
 std::map <string, NetCDFSimple *> _ncdfmap;
 std::vector <string> _staggeredDims;
 std::vector <string> _dimNames; // Names of all dimensions
 std::vector <size_t> _dimLens; // Names of all dimensions
 string _missingValAttName;
 std::map <string, vector <double> > _timesMap; // map variable to time
 std::vector <double> _times;   // all valid time coordinates
 std::vector <string> _failedVars;  // Varibles that could not be added
 std::map <string, DerivedVar *> _derivedVarsMap;
 DerivedVar * _derivedVar; // if current opened variable is derived this is it

 // 
 // file handle for an open variable
 //
 class fileHandle {
 public:
  fileHandle();
  DerivedVar *_derived_var;
  NetCDFSimple *_ncdfptr;
  int _fd;              // NetCDFSimple open file descriptor
  size_t _local_ts;
  int _slice;
  bool _first_slice;
  unsigned char *_slicebuf;
  size_t _slicebufsz;
  unsigned char *_linebuf;
   size_t _linebufsz;
  TimeVaryingVar _tvvars;
  bool _has_missing;
  double _missing_value;
 };
 //
 // Open file data
 //
 std::map<int, NetCDFCollection::fileHandle> _ovr_table;

 void ReInitialize();

 int _InitializeTimesMap(
    const std::vector <string> &files, 
    const std::vector <string> &time_dimnames,
    const std::vector <string> &time_coordvars,
    std::map <string, std::vector <double> > &timesMap,
    std::vector <double> &times,
    int &file_org
 ) const;

 int _InitializeTimesMapCase1(
    const std::vector <string> &files,
    std::map <string, std::vector <double> > &timesMap
 ) const;

 int _InitializeTimesMapCase2(
    const std::vector <string> &files,
    const std::vector <string> &time_dimnames,
    std::map <string, std::vector <double> > &timesMap
 ) const;

 int _InitializeTimesMapCase3(
    const std::vector <string> &files,
    const std::vector <string> &time_dimnames,
    const std::vector <string> &time_coordvars,
    std::map <string, std::vector <double> > &timesMap
 ) const;

 void _InterpolateLine(
    const float *src, size_t n, size_t stride, 
    bool has_missing, float mv, float *dst
 ) const;

 void _InterpolateSlice(
    size_t nx, size_t ny, bool xstag, bool ystag, 
    bool has_missing, float mv, float *slice
 ) const;

int _GetTimesMap(
    NetCDFSimple *netcdf,
    const std::vector <string> &time_coordvars,
    const std::vector <string> &time_dimnames,
    std::map <string, std::vector <double> > &timesmap
 ) const;

 float *_Get1DVar(
    NetCDFSimple *netcdf,
    const NetCDFSimple::Variable &variable
 ) const ;

 int _get_var_index(
    const vector <NetCDFSimple::Variable> variables, string varname
 ) const;


};
};
 
 
#endif