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 <netcdf.h>
#include <vapor/MyBase.h>
#include <vapor/NetCDFSimple.h>
 
namespace VAPoR {
 
 
//
 
class VDF_API NetCDFCollection : public Wasp::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 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 std::vector<bool> GetDimsAreTimeVarying() const { return _dimIsTimeVarying; }
 
    long GetDimLengthAtTime(string name, long ts);
 
    //
    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[], double *data, int fd = 0);
    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(size_t start[], size_t count[], char *data, int fd = 0);
    virtual int Read(std::vector<size_t> start, std::vector<size_t> count, double *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(double *data, int fd = 0);
    virtual int Read(float *data, int fd = 0);
    virtual int Read(char *data, int fd = 0);
    virtual int Read(int *data, int fd = 0);
 
    //
    virtual int ReadSlice(float *data, int fd = 0);
 
    //
    virtual int SeekSlice(int offset, int whence, int fd = 0);
 
    //
    virtual int Close(int fd = 0);
 
    //
    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() : 1); };
        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;
        void                Sort();
 
        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.
    };
 
protected:
    bool _GetVariableInfo(string varname, NetCDFSimple::Variable &variable) const;
 
private:
    std::map<string, TimeVaryingVar> _variableList;
    std::map<string, NetCDFSimple *> _ncdfmap;
    std::vector<string>              _dimNames;    // Names of all dimensions
    std::vector<size_t>              _dimLens;     // Names of all dimensions
    std::vector<bool>                _dimIsTimeVarying;
    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
 
    //
    // file handle for an open variable
    //
    class fileHandle {
    public:
        fileHandle();
        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::map<string, size_t> &timeDimLens, std::vector<double> &times, int &file_org) const;
 
    int _InitializeTimesMapCase1(const std::vector<string> &files, std::map<string, std::vector<double>> &timesMap, std::map<string, size_t> &timeDimLens) const;
 
    int _InitializeTimesMapCase2(const std::vector<string> &files, const std::vector<string> &time_dimnames, std::map<string, std::vector<double>> &timesMap,
                                 std::map<string, size_t> &timeDimLens) 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,
                                 map<string, size_t> &timeDimLens) 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;
 
    double *_Get1DVar(NetCDFSimple *netcdf, const NetCDFSimple::Variable &variable) const;
 
    int _get_var_index(const vector<NetCDFSimple::Variable> variables, string varname) const;
 
    template<typename T> int _read_template(T *data, int fd);
    template<typename T> int _read_template(size_t start[], size_t count[], T *data, int fd);
    template<typename T> int _read_slice_template(T *data, int fd);
};
};    // namespace VAPoR
 
#endif