NodeCoupling.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2026 Caleb Buahin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#ifndef OPENSWMM_ENGINE_2D_NODE_COUPLING_HPP
#define OPENSWMM_ENGINE_2D_NODE_COUPLING_HPP
 
#include <unordered_map>
 
#include "../data/MeshData.hpp"
#include "../data/SurfaceStateData.hpp"
#include "../data/SolverOptions2D.hpp"
#include "../../data/NodeCoupling2DData.hpp"
#include "ExchangeLaw.hpp"
 
// Forward declaration — avoid pulling in full SimulationContext
namespace openswmm {
struct SimulationContext;
struct NodeData;
}
 
namespace openswmm::twoD {

struct CouplingPoint {
    int cell_idx;       
    int vertex_idx;     
    int node_idx;       
    double cd;          
    double area;        
    bool is_outfall;    
    bool has_flap_gate; 
    bool area_authored = true;
    bool cd_authored = true;
    int8_t law = 0;
    exchange::Geometry geo;      
    exchange::Coefficients coef; 
    double chamber_area = 0.0;
    bool equalize = false;
    int head_begin = 0;
    int head_end = 0;
    double spread = 0.0;
    double tw_relax = 0.0;
};

std::vector<CouplingPoint> buildCouplingPoints(const MeshData& mesh, const SimulationContext& ctx);

void resolveExchangeStructure(CouplingPoint& cp, const MeshData& mesh, const SimulationContext& ctx,
                              const SolverOptions2D& opts, int row, NodeCoupling2DType type,
                              double project_len_to_m);

double computeNodeCouplingDQdh1d(const CouplingPoint& cp, const MeshData& mesh,
                                 const SurfaceStateData& state, const NodeData& nodes,
                                 const SolverOptions2D& opts) noexcept;

int accumulateOutfallDischargeStep(const std::vector<CouplingPoint>& cps, const MeshData& mesh,
                                   const SurfaceStateData& state, const SimulationContext& ctx,
                                   const SolverOptions2D& opts, double dt,
                                   std::vector<double>& accum_m3,
                                   std::vector<double>& cell_budget_m3, double* sample_row);

void injectAccumulatedExchange(const std::vector<CouplingPoint>& cps, const MeshData& mesh,
                               SurfaceStateData& state, const std::vector<double>& accum_m3,
                               double window_dt, double sign,
                               const std::vector<double>* node_conc = nullptr);

double computeNodeCouplingQ(const CouplingPoint& cp, const MeshData& mesh,
                            const SurfaceStateData& state, const NodeData& nodes,
                            const SolverOptions2D& opts, const double* provisional_vol_m3 = nullptr,
                            double h1d_offset_m = 0.0) noexcept;

void scatterCouplingToYdot(const MeshData& mesh, const SurfaceStateData& state,
                           const CouplingPoint& cp, double Q, double* ydot) noexcept;

void updateOutfallBoundaries(const std::vector<CouplingPoint>& cps, const MeshData& mesh,
                             const SurfaceStateData& state, SimulationContext& ctx,
                             const SolverOptions2D& opts, double dt);
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_ENGINE_2D_NODE_COUPLING_HPP