NetCDFCFCollection.h

Go to the documentation of this file.

//
// $Id$
//


#ifndef _NetCDFCFCollection_h_
#define _NetCDFCFCollection_h_

#include <vector>
#include <map>
#include <algorithm>

#include <sstream>
#include <vapor/MyBase.h>
#include <vapor/UDUnitsClass.h>
#include <vapor/NetCDFCollection.h>

union ut_unit;
struct ut_system;

namespace VAPoR {

//
//

class VDF_API NetCDFCFCollection : public NetCDFCollection {
public:
 
 NetCDFCFCollection();
 virtual ~NetCDFCFCollection();

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


 //
 virtual bool IsCoordVarCF(string var) const {
    return(std::find( _coordinateVars.begin(), _coordinateVars.end(), var) != _coordinateVars.end());
 }

 //
 virtual bool IsAuxCoordVarCF(string var) const {
    return(std::find( _auxCoordinateVars.begin(),
    _auxCoordinateVars.end(), var) != _auxCoordinateVars.end());
 }


 //
 virtual bool IsLatCoordVar(string var) const {
    return(std::find( _latCoordVars.begin(),
    _latCoordVars.end(), var) != _latCoordVars.end());
 }

 //
 virtual bool IsLonCoordVar(string var) const {
    return(std::find( _lonCoordVars.begin(),
    _lonCoordVars.end(), var) != _lonCoordVars.end());
 }

 //
 virtual bool IsTimeCoordVar(string var) const {
    return(std::find( _timeCoordVars.begin(),
    _timeCoordVars.end(), var) != _timeCoordVars.end());
 }

 //
 virtual bool IsVertCoordVar(string var) const {
    return(std::find( _vertCoordVars.begin(),
    _vertCoordVars.end(), var) != _vertCoordVars.end());
 }

 virtual bool IsVertCoordVarUp(string var) const;
 
 

 virtual std::vector <string> GetLatCoordVars() const {return(_latCoordVars); };

 virtual std::vector <string> GetLonCoordVars() const {return(_lonCoordVars); };

 virtual std::vector <string> GetTimeCoordVars() const {return(_timeCoordVars); };

 virtual std::vector <string> GetVertCoordVars() const {return(_vertCoordVars); };

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

 //
 virtual int GetVarCoordVarNames(string var, std::vector <string> &cvars) const;

 virtual int GetVarUnits(string var, string &units) const;

 const UDUnits *GetUDUnits() const {return(_udunit); };


 virtual int Convert(
    const string from,
    const string to,
    const double *src,
    double *dst,
    size_t n
 ) const;
 virtual int Convert(
    const string from,
    const string to,
    const float *src,
    float *dst,
    size_t n
 ) const;


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

 virtual int OpenRead(size_t ts, string varname);

 virtual bool IsVertDimensionless(string cvar) const;

 virtual int InstallStandardVerticalConverter(
    string cvar, string newvar, string units = "meters"
 );

 //
 virtual void UninstallStandardVerticalConverter(string cvar) ;

 virtual int InstallStandardTimeConverter(
    string cvar, string newvar, string units = "seconds"
 );

 //
 virtual void UninstallStandardTimeConverter(string cvar) ;

 //
 void InstallDerivedCoordVar(string varname, DerivedVar *derivedVar, int axis);

 void RemoveDerivedVar(string varname);



 // 
 bool GetMapProjectionProj4(
    string varname, string &proj4string
 ) const ;

 void FormatTimeStr(double time, string &str) const;

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

private:

 class DerivedVar_ocean_s_coordinate_g1 : public NetCDFCollection::DerivedVar {
 public:
  DerivedVar_ocean_s_coordinate_g1(
    NetCDFCFCollection *ncdfcf, 
    const std::map <string, string> &formula_map
  );
  virtual ~DerivedVar_ocean_s_coordinate_g1();

  virtual int Open(size_t ts);
  virtual int ReadSlice(float *slice, int);
  virtual int Read(float *buf, int);
  virtual int SeekSlice(int offset, int whence, int fd);
  virtual int Close(int) {_is_open = false; return(0); };
  virtual bool TimeVarying() const {return(false); };
  virtual std::vector <size_t>  GetSpatialDims() const { return(_dims); }
  virtual std::vector <string>  GetSpatialDimNames() const { return(_dimnames); }
  virtual size_t  GetTimeDim() const { return(0); }
  virtual string  GetTimeDimName() const { return(""); };
  virtual bool GetMissingValue(double &mv) const {mv=0.0; return(false); }

 private:
  std::vector <size_t> _dims;
  std::vector <string> _dimnames;
  size_t _slice_num;
  float *_s;
  float *_C;
  float *_eta;
  float *_depth;
  float _depth_c;
  string _svar;
  string _Cvar;
  string _etavar;
  string _depthvar;
  string _depth_cvar;
  bool _is_open;
  bool _ok;
 };

 class DerivedVar_ocean_s_coordinate_g2 : public NetCDFCollection::DerivedVar {

 public:
  DerivedVar_ocean_s_coordinate_g2(
    NetCDFCFCollection *ncdfcf, 
    const std::map <string, string> &formula_map
  );
  virtual ~DerivedVar_ocean_s_coordinate_g2();

  virtual int Open(size_t ts);
  virtual int ReadSlice(float *slice, int);
  virtual int Read(float *buf, int);
  virtual int SeekSlice(int offset, int whence, int fd);
  virtual int Close(int) {_is_open = false; return(0); };
  virtual bool TimeVarying() const {return(false); };
  virtual std::vector <size_t>  GetSpatialDims() const { return(_dims); }
  virtual std::vector <string>  GetSpatialDimNames() const { return(_dimnames); }
  virtual size_t  GetTimeDim() const { return(0); }
  virtual string  GetTimeDimName() const { return(""); };
  virtual bool GetMissingValue(double &mv) const {mv=0.0; return(false); }

 private:
  std::vector <size_t> _dims;
  std::vector <string> _dimnames;
  size_t _slice_num;
  float *_s;
  float *_C;
  float *_eta;
  float *_depth;
  float _depth_c;
  string _svar;
  string _Cvar;
  string _etavar;
  string _depthvar;
  string _depth_cvar;
  bool _is_open;
  bool _ok;
 };


class DerivedVar_AHSPC : public NetCDFCollection::DerivedVar {

public:
  DerivedVar_AHSPC(
    NetCDFCFCollection *ncdfcf, 
    const std::map <string, string> &formula_map
  );  
  virtual ~DerivedVar_AHSPC();
  virtual float GetMax() { return _max; }
  virtual float GetMin() { return _min; }
  virtual void SetMax(float val) { _max = val; }
  virtual void SetMin(float val) { _min = val; }
  virtual int Open(size_t ts);
  virtual int ReadSlice(float *slice, int);
  virtual int Read(float *buf, int);
  virtual int SeekSlice(int offset, int whence, int fd);
  virtual int Close(int) {_is_open = false; return(0); };
  virtual bool TimeVarying() const {return(false); };
  virtual std::vector <size_t>  GetSpatialDims() const { return(_dims); }
  virtual std::vector <string>  GetSpatialDimNames() const { return(_dimnames); }
  virtual size_t  GetTimeDim() const { return(0); }
  virtual string  GetTimeDimName() const { return(""); };
  virtual bool GetMissingValue(double &mv) const {mv=0.0; return(false); }

 private:
  virtual int CalculateElevation();
  virtual int DCZ2(const float*  PS1,    const float*  PHIS1, 
                         float** TV2,    const int     NL, 
                   const float   P0,           float** HYBA,         float** HYBB,
                   const int     KLEV,   const int     MLON,   const int     MLON2,
                         float** HYPDLN,       float** HYALPH, float** PTERM,
                   float** ZSLICE);
  std::vector <size_t> _dims;
  std::vector <string> _dimnames;
  size_t _slice_num;
  float *PS1;
  float *PHIS1;
  float *PS;
  float *PHIS;
  float *TV;
  float P0;
  float *HYAM;
  float *HYBM;
  float *HYAI;
  float *HYBI;
  float *_Z3;
  bool _is_open;
  bool _ok;
  float _min;
  float _max;
 };

 class DerivedVar_noop : public NetCDFCollection::DerivedVar {

 public:
  DerivedVar_noop(
    NetCDFCFCollection *ncdfcf, 
    const std::map <string, string> &formula_map, string units
  );
  virtual ~DerivedVar_noop() {}

  virtual int Open(size_t ts);
  virtual int ReadSlice(float *slice, int fd);
  virtual int Read(float *buf, int fd);
  virtual int SeekSlice(int offset, int whence, int fd);
  virtual int Close(int fd) {return(_ncdfc->Close(fd)); };
  virtual bool TimeVarying() const {return(_ncdfc->IsTimeVarying(_zvar)); };
  virtual std::vector <size_t>  GetSpatialDims() const {
    return(_ncdfc->GetSpatialDims(_zvar));
  };
  virtual std::vector <string>  GetSpatialDimNames() const { 
    return(_ncdfc->GetSpatialDimNames(_zvar));
  };
  virtual size_t  GetTimeDim() const { 
    return(_ncdfc->GetTimeDim(_zvar));
  };
  virtual string  GetTimeDimName() const {
    return(_ncdfc->GetTimeDimName(_zvar));
  };
    
  virtual bool GetMissingValue(double &mv) const {
    return(_ncdfc->GetMissingValue(_zvar, mv));
  };
    

 private:
  string _zvar;
  string _native_units;
  string _derived_units;
 };

 class DerivedVarTime : public NetCDFCollection::DerivedVar {
 public:
  DerivedVarTime(
    NetCDFCFCollection *ncdfcf,
    string native_var, string native_units, string derived_units
  );
  virtual ~DerivedVarTime();

  virtual int Open(size_t ts);
  virtual int ReadSlice(float *slice, int);
  virtual int Read(float *buf, int);
  virtual int SeekSlice(int offset, int whence, int fd);
  virtual int Close(int) {return(0); };
  virtual bool TimeVarying() const {return(true); };
  virtual std::vector <size_t>  GetSpatialDims() const { return(_dims); }
  virtual std::vector <string>  GetSpatialDimNames() const { return(_dimnames); }
  virtual size_t  GetTimeDim() const { return(_timedim); }
  virtual string  GetTimeDimName() const { return(_timedimname); };
  virtual bool GetMissingValue(double &mv) const {mv=0.0; return(false); }

 private:
  string _native_var;
  string _native_units;
  string _derived_units;
  std::vector <size_t> _dims;
  std::vector <string> _dimnames;
  size_t _timedim;
  string _timedimname;
  bool _first;
  size_t _ts;
  double *_timecoords;
 };

 std::map <string, DerivedVar *> _derivedVarsMap;
 std::vector <std::string> _coordinateVars;
 std::vector <std::string> _auxCoordinateVars;
 std::vector <std::string> _lonCoordVars;
 std::vector <std::string> _latCoordVars;
 std::vector <std::string> _vertCoordVars;
 std::vector <std::string> _timeCoordVars;

 UDUnits    *_udunit;

 //
 // Map a variable name to it's missing value (if any)
 //
 std::map <string, double> _missingValueMap;

 std::vector <std::string> _GetCoordAttrs(
    const NetCDFSimple::Variable &varinfo
 ) const;

 int _Initialize(const std::vector <string> &files);

 //
 bool _IsCoordinateVar(const NetCDFSimple::Variable &varinfo) const; 

 
 bool _IsLonCoordVar(
    const NetCDFSimple::Variable &varinfo
 ) const;

 bool _IsLatCoordVar(
     const NetCDFSimple::Variable &varinfo
 ) const;
 
 bool _IsVertCoordVar(
    const NetCDFSimple::Variable &varinfo 
 ) const;

 bool _IsTimeCoordVar(
     const NetCDFSimple::Variable &varinfo 
 ) const;

 bool _GetMissingValue(string varname, string &attname, double &mv)  const;
 void _GetMissingValueMap(map <string, double> &missingValueMap) const;

 int _parse_formula(
    string formula_terms, map <string, string> &parsed_terms
 ) const;



};
};
 
 
#endif