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/ActiveSetData.hpp"
#include "data/MeshData.hpp"
#include "data/SurfaceStateData.hpp"
#include "data/SolverOptions2D.hpp"
#include "data/BoundaryData.hpp"
#include "data/PendingRows2D.hpp"
#include "coupling/NodeCoupling.hpp"
#include "mesh/RainfallInterpolator.hpp"
 
#include <memory>
#include <unordered_map>
#include <vector>
#ifdef OPENSWMM_HAS_2D
#include "solver/ISurfaceSolver.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 prepareOneShotForcing(SimulationContext& ctx);

    void finalize(SimulationContext& ctx);

    double computeCflHint(const SimulationContext& ctx) const;

    bool isActive() const noexcept { return active_; }

    void prepareForEdit();

    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_; }

    using PendingBoundaryRow = twoD::PendingBoundaryRow;
    std::vector<PendingBoundaryRow>& pendingBCRows() noexcept { return pending_bc_rows_; }
    const std::vector<PendingBoundaryRow>& pendingBCRows() const noexcept { return pending_bc_rows_; }

    using PendingEdgeConveyanceRow = twoD::PendingEdgeConveyanceRow;
    std::vector<PendingEdgeConveyanceRow>& pendingEdgeConveyanceRows() noexcept {
        return pending_edge_conveyance_rows_;
    }
    const std::vector<PendingEdgeConveyanceRow>& pendingEdgeConveyanceRows() const noexcept {
        return pending_edge_conveyance_rows_;
    }

    double totalVolume() const;

    double totalExchangeFlow() const;
#ifdef OPENSWMM_HAS_2D
    long lastCvodeSteps() const {
        return solver_ ? solver_->last_num_steps() : 0;
    }
    double lastCvodeStepSize() const {
        return solver_ ? solver_->last_step_size() : 0.0;
    }
#else
    long lastCvodeSteps() const { return 0; }
    double lastCvodeStepSize() const { return 0.0; }
#endif
 
private:
    void drainPendingRows();
 
    MeshData         mesh_;
    SurfaceStateData state_;
    SolverOptions2D  options_;
    BoundaryData     boundary_;

    std::vector<PendingBoundaryRow> pending_bc_rows_;

    std::vector<PendingEdgeConveyanceRow> pending_edge_conveyance_rows_;
 
    std::vector<CouplingPoint> coupling_points_;
    std::vector<CouplingPoint> node_coupling_points_;
 
    bool   active_           = false;
    int    coupling_counter_ = 0;
    double sim_time_         = 0.0;
    double pending_dt_       = 0.0;
    bool   force_next_window_ = false;

    double prev_boundary_cum_ = 0.0;

    std::unordered_map<int, double> outfall_applied_q_;
    long outfall_clamp_windows_ = 0;
    long failed_advance_windows_ = 0;

    double cfl_hint_ = 1.0e30;
    std::vector<int> cfl_cells_;
    void updateCflHint();

    ActiveSetData active_set_;

    double effective_window_ = 0.0;
    double window_target_ = 0.0;
    int    clean_windows_ = 0;
    long   quiescent_windows_ = 0;
    double last_t_ = 0.0;

    void fireAdvanceWindow(SimulationContext& ctx, double dt, double t);

    bool boundary_names_resolved_ = false;
#ifdef OPENSWMM_HAS_2D
    std::unique_ptr<ISurfaceSolver> solver_;
#endif

    void updateRainfall(SimulationContext& ctx);

    RainfallInterpolator interp_;

    std::vector<double> rain_si_;

    void resolveBoundaryValues(SimulationContext& ctx, double t);

    void accumulateMassBalance(SimulationContext& ctx, double dt);
};
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_ENGINE_2D_SURFACE_ROUTER_HPP