WASP.h

Go to the documentation of this file.

#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>

#ifndef _WASP_H_
#define _WASP_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 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 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, 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, unsigned char *data
 );

 //
 virtual int GetVar(float *data);
 virtual int GetVar(double *data);
 virtual int GetVar(int *data);
 virtual int GetVar(unsigned char *data);

 //
 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:

 VetsUtil::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;
 VetsUtil::SmartBuf _blockbuf;    // Dynamic storage for blocks
 VetsUtil::SmartBuf _coeffbuf;    // Dynamic storage wavelet coefficients
 VetsUtil::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
 );


};

}

#endif //   _WASP_H_