NetCDFParser.h

#pragma once
 
namespace netcdf_sinmod
{
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; 
};
} // namespace netcdf_sinmod
 
#include "netcdf-cxx4/netcdf"
 
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
using std::string;
using std::vector;
 
namespace netcdf_sinmod
{
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() const
   {
      return m_error_message;
   }
 
private:
   string m_error_message;
};
 
class Parser
{
public:
   Parser();
 
   ~Parser(void);
 
   Parser(const Parser&)            = delete; 
   Parser& operator=(const Parser&) = delete; 
 
   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; 
   string m_file_path;   
 
   void set_to_NULL();
 
   void read_dynamic_variable_data(double* value_array, variable_info variable);
 
   void read_variable_info_from_file(variable_info& variable);
 
   void check_dimension_order(const variable_info& variable);
 
   int dimension_size(const string& dimension_name);
 
   void read_resolution();
 
   void report_exception(string error_message);
 
   std::unique_ptr<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;    
 
   std::optional<Exception> m_exception_collector; 
};
} // namespace netcdf_sinmod