NetCDFSimple.h

Go to the documentation of this file.

//
// $Id$
//
 
#ifndef _NetCDFSimple_h_
#define _NetCDFSimple_h_
 
#include <vector>
#include <map>
 
#include <sstream>
#include <vapor/MyBase.h>
 
namespace VAPoR {
 
//
//
class VDF_API NetCDFSimple : public Wasp::MyBase {
public:
    NetCDFSimple();
    virtual ~NetCDFSimple();
 
    //
    class Variable {
    public:
        Variable();
 
        Variable(string varname, std::vector<string> dimnames, int type);
 
        //
        string GetName() const { return (_name); };
 
        //
        std::vector<string> GetAttNames() const;
 
        std::vector<string> GetDimNames() const { return (_dimnames); };
        void                SetDimNames(const std::vector<string> dimnames) { _dimnames = dimnames; }
 
        //
        int GetAttType(string name) const;
 
        int GetXType() const { return (_type); };
 
        //
        void GetAtt(string name, std::vector<double> &values) const;
        void GetAtt(string name, std::vector<long> &values) const;
        void GetAtt(string name, string &values) const;
 
        //
        void SetAtt(string name, const std::vector<double> &values) { _flt_atts.push_back(make_pair(name, values)); }
        void SetAtt(string name, const std::vector<long> &values) { _int_atts.push_back(make_pair(name, values)); }
        void SetAtt(string name, const string &values) { _str_atts.push_back(make_pair(name, values)); }
 
        VDF_API friend std::ostream &operator<<(std::ostream &o, const Variable &var);
        VDF_API friend bool          operator==(const Variable &v1, const Variable &v2)
        {
            return ((v1._name == v2._name) && (v1._dimnames == v2._dimnames) && (v1._flt_atts == v2._flt_atts) && (v1._int_atts == v2._int_atts) && (v1._str_atts == v2._str_atts)
                    && (v1._type == v2._type));
        }
 
    private:
        string                                              _name;        // variable name
        std::vector<string>                                 _dimnames;    // order list of dimension names
        std::vector<std::pair<string, std::vector<double>>> _flt_atts;
        std::vector<std::pair<string, std::vector<long>>>   _int_atts;
        std::vector<std::pair<string, string>>              _str_atts;
        int                                                 _type;    // netCDF variable type
    };
 
    virtual int Initialize(string path);
 
    virtual int OpenRead(const NetCDFSimple::Variable &variable);
 
    int Read(const size_t start[], const size_t count[], double *data, int fd = 0) const;
    int Read(const size_t start[], const size_t count[], float *data, int fd = 0) const;
    int Read(const size_t start[], const size_t count[], int *data, int fd = 0) const;
    int Read(const size_t start[], const size_t count[], char *data, int fd = 0) const;
 
    //
    virtual int Close(int fd = 0);
 
    const std::vector<NetCDFSimple::Variable> &GetVariables() const { return (_variables); };
 
    void GetDimensions(std::vector<string> &names, std::vector<size_t> &dims) const;
 
    //
    string DimName(int id) const;
 
    //
    size_t DimLen(string name) const;
 
    //
    int DimId(string name) const;
 
    //
    std::vector<string> GetAttNames() const;
 
    //
    int GetAttType(string name) const;
 
    //
    void GetAtt(string name, std::vector<double> &values) const;
    void GetAtt(string name, std::vector<long> &values) const;
    void GetAtt(string name, string &values) const;
 
    static bool IsNCTypeInt(int type);
 
    static bool IsNCTypeFloat(int type);
 
    static bool IsNCTypeText(int type);
 
    VDF_API friend std::ostream &operator<<(std::ostream &o, const NetCDFSimple &nc);
 
protected:
    int                                                 _ncid;
    std::map<int, int>                                  _ovr_table;    // open variable map: fd -> varid
    string                                              _path;
    std::vector<string>                                 _dimnames;
    std::vector<size_t>                                 _dims;
    std::vector<string>                                 _unlimited_dimnames;
    std::vector<std::pair<string, std::vector<double>>> _flt_atts;
    std::vector<std::pair<string, std::vector<long>>>   _int_atts;
    std::vector<std::pair<string, string>>              _str_atts;
    std::vector<NetCDFSimple::Variable>                 _variables;
 
    int _GetAtts(int ncid, int varid, std::vector<std::pair<string, std::vector<double>>> &flt_atts, std::vector<std::pair<string, std::vector<long>>> &int_atts,
                 std::vector<std::pair<string, string>> &str_atts);
};
 
};    // namespace VAPoR
#endif