WASP.h

Go to the documentation of this file.

 
#ifndef _WASP_H_
#define _WASP_H_
 
#include <vector>
#include <map>
#include <iostream>
#include <netcdf.h>
#include <vapor/NetCDFCpp.h>
#include <vapor/Compressor.h>
#include <vapor/EasyThreads.h>
#include <vapor/utils.h>
 
namespace VAPoR {
 
//
class WASP_API WASP : public VAPoR::NetCDFCpp {
public:
    //
    WASP(int nthreads = 0);
    virtual ~WASP();
 
    //
    virtual int Create(string path, int cmode, size_t initialsz, size_t &bufrsizehintp, int numfiles);
 
    //
    virtual int Open(string path, int mode);
 
    //
    virtual int SetFill(int fillmode, int &old_modep);
 
    //
    virtual int EndDef() const;
 
    virtual int Close();
 
    //
    virtual int InqVarDimlens(string name, int level, vector<size_t> &dims, vector<size_t> &bs) const;
 
    //
    virtual int InqVarDims(string name, vector<string> &dimnames, vector<size_t> &dims) const;
 
    virtual int InqVarCompressionParams(string name, string &wname, vector<size_t> &bs, vector<size_t> &cratios) const;
 
    //
    static int InqDimsAtLevel(string wname, int level, vector<size_t> dims, vector<size_t> bs, vector<size_t> &dims_at_level, vector<size_t> &bs_at_level);
 
    //
    virtual int InqVarNumRefLevels(string name) const;
 
    static bool InqCompressionInfo(vector<size_t> bs, string wname, size_t &nlevels, size_t &maxcratio);
 
    //
    virtual int DefVar(string name, int xtype, vector<string> dimnames, string wname, vector<size_t> bs, vector<size_t> cratios);
 
    virtual int DefVar(string name, int xtype, vector<string> dimnames, string wname, vector<size_t> bs, vector<size_t> cratios, double missing_value);
 
    // Is this needed?
    virtual int DefVar(string name, int xtype, vector<string> dimnames) { return (NetCDFCpp::DefVar(name, xtype, dimnames)); };
 
    //
    int DefDim(string name, size_t len) const;
 
    //
    virtual int InqVarCompressed(string varname, bool &compressed) const;
 
    int InqVarWASP(string varname, bool &wasp) const;
 
    //
    virtual int OpenVarWrite(string name, int lod);
 
    //
    virtual int OpenVarRead(string name, int level, int lod);
 
    //
    virtual int CloseVar();
 
    //
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const float *data);
    virtual int PutVar(const float *data);
 
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const double *data);
    virtual int PutVar(const double *data);
 
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const int *data);
    virtual int PutVar(const int *data);
 
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const int16_t *data);
    virtual int PutVar(const int16_t *data);
 
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const unsigned char *data);
    virtual int PutVar(const unsigned char *data);
 
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const float *data, const unsigned char *mask);
    virtual int PutVar(const float *data, const unsigned char *mask);
 
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const double *data, const unsigned char *mask);
    virtual int PutVar(const double *data, const unsigned char *mask);
 
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const int *data, const unsigned char *mask);
    virtual int PutVar(const int *data, const unsigned char *mask);
 
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const int16_t *data, const unsigned char *mask);
    virtual int PutVar(const int16_t *data, const unsigned char *mask);
 
    virtual int PutVara(vector<size_t> start, vector<size_t> count, const unsigned char *data, const unsigned char *mask);
    virtual int PutVar(const unsigned char *data, const unsigned char *mask);
 
    //
    virtual int GetVara(vector<size_t> start, vector<size_t> count, float *data);
    virtual int GetVara(vector<size_t> start, vector<size_t> count, double *data);
    virtual int GetVara(vector<size_t> start, vector<size_t> count, int *data);
    virtual int GetVara(vector<size_t> start, vector<size_t> count, int16_t *data);
 
    virtual int GetVara(vector<size_t> start, vector<size_t> count, unsigned char *data);
 
    //
    virtual int GetVaraBlock(vector<size_t> start, vector<size_t> count, float *data);
    virtual int GetVaraBlock(vector<size_t> start, vector<size_t> count, double *data);
    virtual int GetVaraBlock(vector<size_t> start, vector<size_t> count, int *data);
    virtual int GetVaraBlock(vector<size_t> start, vector<size_t> count, int16_t *data);
    virtual int GetVaraBlock(vector<size_t> start, vector<size_t> count, unsigned char *data);
 
    //
    virtual int GetVar(float *data);
    virtual int GetVar(double *data);
    virtual int GetVar(int *data);
    virtual int GetVar(int16_t *data);
    virtual int GetVar(unsigned char *data);
 
    //
    virtual int CopyVar(string varname, WASP &wasp);
 
    //
    virtual int CopyVarFrom(string varname, NetCDFCpp &ncdf);
 
    //
    virtual int CopyVarTo(string varname, NetCDFCpp &ncdf);
 
    //
    static std::vector<string> GetPaths(string path, int numfiles)
    {
        if (numfiles > 1) {
            return (mkmultipaths(path, numfiles));
        } else {
            std::vector<string> t(1, path);
            return (t);
        }
    }
 
    static string AttNameWavelet() { return ("WASP.Wavelet"); }
 
    static string AttNameBlockSize() { return ("WASP.BlockSize"); }
 
    static string AttNameNumFiles() { return ("WASP.NumFiles"); }
 
    static string AttNameCRatios() { return ("WASP.CRatios"); }
 
    static string AttNameWASP() { return ("WASP"); }
 
    static string AttNameDimNames() { return ("WASP.DimNames"); }
 
    static string AttNameMissingValue() { return ("WASP.MissingValue"); }
 
    static string AttNameVersion() { return ("WASP.Version"); }
 
private:
    Wasp::EasyThreads * _et;
    int                 _nthreads;
    vector<NetCDFCpp>   _ncdfcs;
    vector<NetCDFCpp *> _ncdfcptrs;         // pointers into _ncdfcs;
    bool                _waspFile;          // Is this a WASP file
    int                 _numfiles;          // Number of NetCDF files
    int                 _currentVersion;    // Current WASP version number;
    int                 _fileVersion;       // version number of opened file;
    Wasp::SmartBuf      _blockbuf;          // Dynamic storage for blocks
    Wasp::SmartBuf      _coeffbuf;          // Dynamic storage wavelet coefficients
    Wasp::SmartBuf      _sigbuf;            // Dynamic storage encoded signficance maps
 
    bool                 _open;                // compressed variable open for reading or writing?
    string               _open_wname;          // wavelet name of opened variable
    vector<size_t>       _open_bs;             // block size of opened variable
    vector<size_t>       _open_cratios;        // compression ratios of opened variable
    vector<size_t>       _open_udims;          // uncompressed dims of opened variable
    vector<size_t>       _open_dims;           // compressed dims of opened variable
    int                  _open_lod;            // level-of-detail of opened variable
    int                  _open_level;          // grid refinement level of opened variable
    bool                 _open_write;          // opened variable open for writing?
    bool                 _open_waspvar;        // opened variable is a WASP variable?
    string               _open_varname;        // name of opened variable
    nc_type              _open_varxtype;       // external type of opened variable
    vector<Compressor *> _open_compressors;    // Compressor for opened variable
 
    int _GetBlockAlignedDims(vector<string> dimnames, vector<size_t> bs, vector<string> &badimnames, vector<size_t> &badims) const;
 
    int _GetCompressedDims(vector<string> dimnames, string wname, vector<size_t> bs, vector<size_t> cratios, int xtype, vector<string> &cdimnames, vector<size_t> &cdims,
                           vector<string> &encoded_dim_names, vector<size_t> &encoded_dims) const;
 
    int _InqDimlen(string name, size_t &len) const;
 
    void _get_encoding_vectors(string wname, vector<size_t> bs, vector<size_t> cratios, int xtype, vector<size_t> &ncoeffs, vector<size_t> &encoded_dims) const;
 
    bool _validate_compression_params(string wname, vector<size_t> dims, vector<size_t> bs, vector<size_t> cratios) const;
 
    bool _validate_put_vara_compressed(vector<size_t> start, vector<size_t> count, vector<size_t> bs, vector<size_t> udims, vector<size_t> cratios) const;
 
    bool _validate_get_vara_compressed(vector<size_t> start, vector<size_t> count, vector<size_t> bs, vector<size_t> udims, vector<size_t> cratios, bool unblock) const;
 
    int _get_compression_params(string name, vector<size_t> &bs, vector<size_t> &cratios, vector<size_t> &udims, vector<size_t> &dims, string &wname) const;
 
    template<class T, class U> int _GetVara(vector<size_t> start, vector<size_t> count, bool unblock, T *data, U dummy);
 
    template<class T> int _GetVara(vector<size_t> start, vector<size_t> count, bool unblock_flag, T *data);
 
    static void _dims_at_level(vector<size_t> dims, vector<size_t> bs, int level, string wname, vector<size_t> &dims_level, vector<size_t> &bs_level);
 
    static vector<string> mkmultipaths(string path, int n);
 
    template<class T, class U> int _PutVara(vector<size_t> start, vector<size_t> count, const T *data, const unsigned char *mask, U dummy);
 
    template<class T> int _PutVara(vector<size_t> start, vector<size_t> count, const T *data, const unsigned char *mask);
 
    template<class T> int _CopyHyperSlice(string varname, NetCDFCpp &src_ncdf, NetCDFCpp &dst_ncdf, vector<size_t> start, vector<size_t> count, T *buf) const;
 
    int _CopyVar(string varname, NetCDFCpp &src_ncdf, NetCDFCpp &dst_ncdf) const;
 
    // Determine POD type
    //
    int _NetCDFType(float dummy) { return NC_FLOAT; }
    int _NetCDFType(char dummy) { return NC_BYTE; }
    int _NetCDFType(double dummy) { return NC_DOUBLE; }
    int _NetCDFType(unsigned char dummy) { return NC_UBYTE; }
    int _NetCDFType(int16_t dummy) { return NC_SHORT; }
    int _NetCDFType(int dummy) { return NC_INT; }
    int _NetCDFType(long dummy) { return NC_INT64; }
};
 
}    // namespace VAPoR
 
namespace Wasp {
}
 
#endif    //    _WASP_H_