SurfaceRouter2D.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_2D_SURFACE_ROUTER_HPP
#define OPENSWMM_ENGINE_2D_SURFACE_ROUTER_HPP
 
#include "data/MeshData.hpp"
#include "data/SurfaceStateData.hpp"
#include "data/SolverOptions2D.hpp"
#include "data/BoundaryData.hpp"
#include "coupling/NodeCoupling.hpp"
 
#ifdef OPENSWMM_HAS_2D
#include "solver/CvodeSurfaceSolver.hpp"
#endif
 
namespace openswmm {
struct SimulationContext;
}
 
namespace openswmm::twoD {
 
class SurfaceRouter2D {
public:
    SurfaceRouter2D() = default;
    ~SurfaceRouter2D() = default;
 
    // Non-copyable, movable
    SurfaceRouter2D(const SurfaceRouter2D&) = delete;
    SurfaceRouter2D& operator=(const SurfaceRouter2D&) = delete;
    SurfaceRouter2D(SurfaceRouter2D&&) = default;
    SurfaceRouter2D& operator=(SurfaceRouter2D&&) = default;
 
    void initialize(SimulationContext& ctx);
 
    void step(SimulationContext& ctx, double dt, double t);
 
    void updateOutfallsPreRouting(SimulationContext& ctx);
 
    void advancePostRouting(SimulationContext& ctx, double dt, double t);
 
    void finalize();
 
    double computeCflHint(const SimulationContext& ctx) const;
 
    bool isActive() const noexcept { return active_; }
 
    const MeshData& mesh() const noexcept { return mesh_; }
 
    MeshData& mesh() noexcept { return mesh_; }
 
    const SurfaceStateData& state() const noexcept { return state_; }
 
    SurfaceStateData& state() noexcept { return state_; }
 
    const SolverOptions2D& options() const noexcept { return options_; }
 
    SolverOptions2D& options() noexcept { return options_; }
 
    const BoundaryData& boundary() const noexcept { return boundary_; }
 
    BoundaryData& boundary() noexcept { return boundary_; }
 
    struct PendingBoundaryRow {
        int         tri      = 0;
        int         edge     = 0;     
        int         bc_type  = 0;     
        double      param1   = 0.0;   
        std::string name;             
        std::string group;            
    };
    std::vector<PendingBoundaryRow>& pendingBCRows() noexcept { return pending_bc_rows_; }
    const std::vector<PendingBoundaryRow>& pendingBCRows() const noexcept { return pending_bc_rows_; }
 
    double totalVolume() const;
 
    double totalExchangeFlow() const;
 
#ifdef OPENSWMM_HAS_2D
    long lastCvodeSteps() const { return cvode_solver_.last_num_steps(); }
    double lastCvodeStepSize() const { return cvode_solver_.last_step_size(); }
#else
    long lastCvodeSteps() const { return 0; }
    double lastCvodeStepSize() const { return 0.0; }
#endif
 
private:
    MeshData         mesh_;
    SurfaceStateData state_;
    SolverOptions2D  options_;
    BoundaryData     boundary_;
 
    std::vector<PendingBoundaryRow> pending_bc_rows_;
 
    std::vector<CouplingPoint> coupling_points_;
 
    bool   active_           = false;
    int    coupling_counter_ = 0;
    double sim_time_         = 0.0;
 
#ifdef OPENSWMM_HAS_2D
    CvodeSurfaceSolver cvode_solver_;
#endif
 
    void updateRainfall(SimulationContext& ctx);
};
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_ENGINE_2D_SURFACE_ROUTER_HPP