NetCDFParser.h

#ifndef C_NETCDF_PARSER_H
#define C_NETCDF_PARSER_H
 
namespace NetCDFsinmod
{
    struct Date {int year; int month; int day; int hour; int minute; int second;};
    struct Grid {
        int numX; 
        int numY; 
        int numZ; 
        int numT; 
        double sizeX; 
        double sizeY; 
    };
}
 
#ifdef NETCDFCPP_AVAILABLE
#include "netcdf-cxx4/netcdf"
 
#include <string>
#include <vector>
 
using std::string;
using std::vector;
 
namespace NetCDFsinmod
{
    class Exception; 
    class Parser
    {
    public:
 
        Parser(); 
        ~Parser(void); 
        void LoadFile(string NetCDF_Filepath); 
        Grid GetGridInfo(); 
        void GetStaticData(double* layer_depth, double* depth_map, Date* timeline); 
 
        void SetCurrentTime(int offset_from_start_time); 
        void GetDynamicData(double* x_velocity, double* y_velocity, double* z_velocity); 
 
    private:
        enum DIMENSION_NUMBER {X_NUM = 0, Y_NUM = 1, Z_NUM = 2, T_NUM = 3, T2_NUM = 4};
        enum DIMENSION_BITMASK {X_MASK = 1<<X_NUM, Y_MASK = 1<<Y_NUM, Z_MASK = 1<<Z_NUM, T_MASK = 1<<T_NUM, T2_MASK = 1<<T2_NUM, VOID_DIMENSION_MASK = 1<<5};
        static const DIMENSION_BITMASK SURFACE = (DIMENSION_BITMASK)(X_MASK | Y_MASK);
        static const DIMENSION_BITMASK DEPTH = Z_MASK;
        static const DIMENSION_BITMASK SPACE = (DIMENSION_BITMASK)(SURFACE | DEPTH);
        static const DIMENSION_BITMASK SPACE_TIME = (DIMENSION_BITMASK)(SPACE | T_MASK);
        static const DIMENSION_BITMASK SURFACE_TIME = (DIMENSION_BITMASK)(SURFACE | T_MASK);
        static const DIMENSION_BITMASK EXPANDED_TIME = (DIMENSION_BITMASK)(T_MASK | T2_MASK);
        static const DIMENSION_BITMASK ALL_SPACE_AND_TIME = (DIMENSION_BITMASK)(SPACE | EXPANDED_TIME);
 
        struct variable_info {string name; netCDF::NcVar ncvar; DIMENSION_BITMASK required_dimensions;};
        struct system_variables {variable_info vx; variable_info vy; variable_info vz; variable_info depth; variable_info layer_depth; variable_info time;};
 
        string  m_x_dim_name; 
        string  m_y_dim_name; 
        string  m_z_dim_name; 
        string  m_t_dim_name; 
        string  m_t2_dim_name;
 
        void set_to_NULL(); 
 
        //bool nctype_has_dim(netCDF::NcVar* nc_dimension_type, string dimension_name); /// test if a nc_type is defined in a specified dimension
        //bool nctype_has_dim(netCDF::NcFile* nc_dimension_type, string dimension_name); /// test if a nc_type is defined in a specified dimension
 
        void read_dynamic_variable_data(double* value_array, variable_info variable);
 
        void read_variable_info_from_file(variable_info& variable);
        void report_exception(string error_message);
        //void check_requirement(bool requires_dimension, bool needs_dimension, string variable_name, string dimension_name);
 
 
        netCDF::NcFile*     m_ncfile; 
        Grid        m_grid; 
        int         m_current_time_offset; 
 
        system_variables m_variables; 
 
        double m_fill_value;
        string m_fill_value_attribute_name;
        string m_offset_value_attribute_name;
        string m_scaling_value_attribute_name;
        string m_resolution_attribute_name;
 
        Exception* m_exception_collector;
    };
 
    class Exception
    {
    public:
        Exception(string errorMessage){
            m_error_message = "Error in NetCDF parser: "+errorMessage;
        }
        void AppendErrorMessage(string errormessage){
            m_error_message.append("\nError in NetCDF parser: "+errormessage);
        }
        string GetErrorMessage(){
            return m_error_message;
        }
    private:
        string m_error_message;
    };
}
 
#endif
 
#endif// NETCDFCPP_AVAILABLE