SurfaceStateData.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_2D_SURFACE_STATE_DATA_HPP
#define OPENSWMM_ENGINE_2D_SURFACE_STATE_DATA_HPP
 
#include <vector>
#include <cstring>
#include <algorithm>
 
namespace openswmm::twoD {
 
struct SurfaceStateData {
 
    // -----------------------------------------------------------------------
    // State variables — per triangle [0, n_triangles)
    // -----------------------------------------------------------------------
 
    std::vector<double> depth;          
    std::vector<double> head;           
 
    // Gradient fields (per triangle)
    std::vector<double> grad_hx;        
    std::vector<double> grad_hy;        
    std::vector<double> grad_hx_lim;    
    std::vector<double> grad_hy_lim;    
 
    // Reconstructed head at vertices — [0, n_vertices)
    std::vector<double> vert_head;      
 
    // Fluxes — flat 2D: [tri * 3 + edge]
    std::vector<double> edge_flux;      
 
    // Source/sink terms — per triangle
    std::vector<double> rainfall;       
    std::vector<double> coupling_flux;  
    std::vector<double> net_source;     
 
    // -----------------------------------------------------------------------
    // Forcing overrides (optional external control)
    // -----------------------------------------------------------------------
 
    std::vector<int8_t> rainfall_forced;      
    std::vector<int8_t> rainfall_persist;     
    std::vector<double> rainfall_force_val;   
    std::vector<int8_t> coupling_forced;      
    std::vector<int8_t> coupling_persist;     
    std::vector<double> coupling_force_val;   
 
    // -----------------------------------------------------------------------
    // Previous step state
    // -----------------------------------------------------------------------
 
    std::vector<double> old_depth;      
 
    // -----------------------------------------------------------------------
    // Cumulative statistics
    // -----------------------------------------------------------------------
 
    std::vector<double> stat_max_depth;     
    std::vector<double> stat_cum_volume;    
 
    // -----------------------------------------------------------------------
    // Lifecycle
    // -----------------------------------------------------------------------
 
    void resize(int n_triangles, int n_vertices) {
        auto nt = static_cast<std::size_t>(n_triangles);
        auto nv = static_cast<std::size_t>(n_vertices);
        auto n3 = nt * 3;
 
        depth.assign(nt, 0.0);
        head.assign(nt, 0.0);
        grad_hx.assign(nt, 0.0);
        grad_hy.assign(nt, 0.0);
        grad_hx_lim.assign(nt, 0.0);
        grad_hy_lim.assign(nt, 0.0);
        vert_head.assign(nv, 0.0);
        edge_flux.assign(n3, 0.0);
        rainfall.assign(nt, 0.0);
        coupling_flux.assign(nt, 0.0);
        net_source.assign(nt, 0.0);
 
        rainfall_forced.assign(nt, 0);
        rainfall_persist.assign(nt, 0);
        rainfall_force_val.assign(nt, 0.0);
        coupling_forced.assign(nt, 0);
        coupling_persist.assign(nt, 0);
        coupling_force_val.assign(nt, 0.0);
 
        old_depth.assign(nt, 0.0);
        stat_max_depth.assign(nt, 0.0);
        stat_cum_volume.assign(nt, 0.0);
    }
 
    void save_state() noexcept {
        std::memcpy(old_depth.data(), depth.data(),
                     depth.size() * sizeof(double));
    }
 
    void reset_state() noexcept {
        std::memcpy(depth.data(), old_depth.data(),
                     old_depth.size() * sizeof(double));
    }
 
    void clear_reset_forcings() noexcept {
        for (std::size_t i = 0; i < rainfall_forced.size(); ++i) {
            if (rainfall_persist[i] == 0) {
                rainfall_forced[i] = 0;
                rainfall_force_val[i] = 0.0;
            }
            if (coupling_persist[i] == 0) {
                coupling_forced[i] = 0;
                coupling_force_val[i] = 0.0;
            }
        }
    }
 
    void update_statistics(const std::vector<double>& tri_area,
                           double dt) noexcept {
        for (std::size_t i = 0; i < depth.size(); ++i) {
            if (depth[i] > stat_max_depth[i])
                stat_max_depth[i] = depth[i];
            stat_cum_volume[i] += depth[i] * tri_area[i] * dt;
        }
    }
};
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_ENGINE_2D_SURFACE_STATE_DATA_HPP