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"
 
// 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;
};

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

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);
 
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_ENGINE_2D_NODE_COUPLING_HPP