MeshData.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_2D_MESH_DATA_HPP
#define OPENSWMM_ENGINE_2D_MESH_DATA_HPP
 
#include <vector>
#include <string>
#include <cstdint>
 
namespace openswmm::twoD {
 
struct MeshData {
 
    // -----------------------------------------------------------------------
    // Vertex arrays — indexed by vertex index [0, n_vertices)
    // -----------------------------------------------------------------------
 
    std::vector<double> vx;             
    std::vector<double> vy;             
    std::vector<double> vz;             
    std::vector<std::string> vtag;      
 
    // -----------------------------------------------------------------------
    // Triangle static properties — indexed by triangle index [0, n_triangles)
    // -----------------------------------------------------------------------
 
    // Connectivity (3 vertex indices per triangle)
    std::vector<int> tri_v0;            
    std::vector<int> tri_v1;            
    std::vector<int> tri_v2;            
 
    // Neighbour connectivity (3 adjacent triangle indices, -1 = boundary)
    std::vector<int> tri_nbr0;          
    std::vector<int> tri_nbr1;          
    std::vector<int> tri_nbr2;          
 
    // Precomputed geometry
    std::vector<double> tri_area;       
    std::vector<double> tri_cx;         
    std::vector<double> tri_cy;         
    std::vector<double> tri_cz;         
 
    // Edge geometry — flat 2D: [tri * 3 + edge]
    std::vector<double> edge_length;    
    std::vector<double> edge_nx;        
    std::vector<double> edge_ny;        
    std::vector<double> edge_mx;        
    std::vector<double> edge_my;        
    std::vector<double> edge_mz;        
 
    // Surface properties
    std::vector<double> mannings_n;     
    std::vector<std::string> tri_tag;   
 
    // -----------------------------------------------------------------------
    // Vertex reconstruction stencil (pseudo-Laplacian weights)
    // -----------------------------------------------------------------------
    // Stored as CSR (compressed sparse row) for variable stencil sizes
    std::vector<int>    vert_stencil_ptr;   
    std::vector<int>    vert_stencil_idx;   
    std::vector<double> vert_stencil_wt;    
 
    // -----------------------------------------------------------------------
    // Coupling maps
    // -----------------------------------------------------------------------
 
    std::vector<int> vert_coupled_node;     
    std::vector<int> tri_coupled_node;      
 
    // Coupling parameters (per vertex/triangle coupling point)
    std::vector<double> vert_coupling_cd;       
    std::vector<double> vert_coupling_area;     
    std::vector<double> tri_coupling_cd;        
    std::vector<double> tri_coupling_area;      
 
    // Deferred resolution names (populated during parsing, cleared after resolve)
    std::vector<std::string> vert_coupled_node_name;
    std::vector<std::string> tri_coupled_node_name;
 
    // -----------------------------------------------------------------------
    // Capacity queries
    // -----------------------------------------------------------------------
 
    int n_vertices()  const noexcept { return static_cast<int>(vx.size()); }
    int n_triangles() const noexcept { return static_cast<int>(tri_v0.size()); }
 
    // -----------------------------------------------------------------------
    // Resize / allocation
    // -----------------------------------------------------------------------
 
    void resize_vertices(int nv) {
        auto n = static_cast<std::size_t>(nv);
        vx.resize(n, 0.0);
        vy.resize(n, 0.0);
        vz.resize(n, 0.0);
        vtag.resize(n);
        vert_coupled_node.resize(n, -1);
        vert_coupled_node_name.resize(n);
        vert_coupling_cd.resize(n, 0.65);
        vert_coupling_area.resize(n, 1.0);
    }
 
    void resize_triangles(int nt) {
        auto n = static_cast<std::size_t>(nt);
        tri_v0.resize(n, 0);
        tri_v1.resize(n, 0);
        tri_v2.resize(n, 0);
        tri_nbr0.resize(n, -1);
        tri_nbr1.resize(n, -1);
        tri_nbr2.resize(n, -1);
        tri_area.resize(n, 0.0);
        tri_cx.resize(n, 0.0);
        tri_cy.resize(n, 0.0);
        tri_cz.resize(n, 0.0);
 
        auto n3 = static_cast<std::size_t>(nt) * 3;
        edge_length.resize(n3, 0.0);
        edge_nx.resize(n3, 0.0);
        edge_ny.resize(n3, 0.0);
        edge_mx.resize(n3, 0.0);
        edge_my.resize(n3, 0.0);
        edge_mz.resize(n3, 0.0);
 
        mannings_n.resize(n, 0.035);
        tri_tag.resize(n);
        tri_coupled_node.resize(n, -1);
        tri_coupled_node_name.resize(n);
        tri_coupling_cd.resize(n, 0.65);
        tri_coupling_area.resize(n, 1.0);
    }
};
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_ENGINE_2D_MESH_DATA_HPP