NetCdf.h

Go to the documentation of this file.

 
#ifndef TSUNAMI_LAB_IO_NETCDF_H
#define TSUNAMI_LAB_IO_NETCDF_H
 
#include "../constants.h"
#include <cstddef>
#include <string>
#include <vector>
 
namespace tsunami_lab {
  namespace io {
    class NetCdf;
  }
}
 
class tsunami_lab::io::NetCdf {
  private:
    int m_ncId = -1;
 
    int m_dimTime = -1;
    int m_dimY    = -1;
    int m_dimX    = -1;
 
    int m_varTime = -1;
    int m_varY    = -1;
    int m_varX    = -1;
    int m_varH    = -1;
    int m_varHu   = -1;
    int m_varHv   = -1;
    int m_varB    = -1;
 
    t_idx m_nx     = 0;
    t_idx m_ny     = 0;
    t_idx m_stride = 0;
 
    t_real m_dxy   = 0;
 
    std::size_t m_timeIdx = 0;
 
    t_idx m_k = 1;
 
    static void check( int i_status, char const * i_what );
 
    void writeSlice( int            i_varId,
                     t_real const * i_data );
 
    static t_idx fast_div_ceil(t_idx a, t_idx b) {
      return (a + b - 1) / b;
    }
  public:
    NetCdf( std::string    i_path,
            t_real         i_dxy,
            t_idx          i_nx,
            t_idx          i_ny,
            t_idx          i_stride,
            t_real const * i_bathymetry,
            t_idx          i_k );
 
    struct Append {};
 
    NetCdf( Append,
            std::string i_path,
            t_real      i_dxy,
            t_idx       i_nx,
            t_idx       i_ny,
            t_idx       i_stride,
            t_idx       i_k );
 
    ~NetCdf();
 
    NetCdf( NetCdf const & )             = delete;
    NetCdf & operator=( NetCdf const & ) = delete;
 
    void writeTimeStep( t_real         i_simTime,
                        t_real const * i_h,
                        t_real const * i_hu,
                        t_real const * i_hv );
 
    std::size_t records() const { return m_timeIdx; }
 
    // ---------------- input side (assignment 5.2) ----------------------
 
    struct Grid {
      t_idx                nx = 0;   
      t_idx                ny = 0;   
      std::vector<t_real>  x;        
      std::vector<t_real>  y;        
      std::vector<t_real>  z;        
 
      bool inBounds( t_real i_x, t_real i_y ) const {
        return !x.empty() && !y.empty()
            && i_x >= x.front() && i_x <= x.back()
            && i_y >= y.front() && i_y <= y.back();
      }
 
      t_real sampleNearest( t_real i_x, t_real i_y ) const;
    };
 
    static Grid read( std::string i_path );
 
    // -------------- checkpoint restart side (assignment 7.1) -----------
 
    void writeCheckpoint( std::string    i_path,
                          t_real const * i_h,
                          t_real const * i_hu,
                          t_real const * i_hv,
                          t_real const * i_bathymetry,
                          t_real         i_simTime,
                          t_idx          i_timeStep,
                          t_real         i_dt );
 
    struct Checkpoint {
      Grid   b;             
      Grid   h;             
      Grid   hu;            
      Grid   hv;            
      t_real simTime  = 0;  
      t_idx  timeStep = 0;  
      t_real dt       = 0;  
 
      t_idx  nx()  const { return b.nx; }                            
      t_idx  ny()  const { return b.ny; }                            
      t_real dxy() const { return b.x.size() > 1 ? b.x[1] - b.x[0] : 0; } 
    };
 
    static bool hasCheckpoint( std::string i_path );
 
    static Checkpoint readCheckpoint( std::string i_path );
};
 
#endif