BoundaryData.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_BOUNDARY_DATA_HPP
#define OPENSWMM_ENGINE_2D_BOUNDARY_DATA_HPP
 
#include "../coupling/RuntimeCoupling.hpp"
#include <vector>
#include <cstdint>
#include <map>
#include <string>
 
namespace openswmm::twoD {

enum class BoundaryType : int8_t {
    WALL = 0,            
    NORMAL_FLOW = 1,     
    SPECIFIED_STAGE = 2, 
    SPECIFIED_FLOW = 3,  
    RATING_CURVE = 4     
};

struct BoundaryData {

    std::vector<int8_t> edge_bc_type;

    std::vector<double> edge_wall_drag;
    std::vector<uint8_t> edge_is_exterior;

    std::vector<double> edge_bed_slope;

    std::vector<double> edge_bc_head;

    std::vector<int> edge_bc_tseries;

    std::vector<std::string> edge_bc_tseries_name;

    std::vector<double> edge_bc_cum_flux;
 
    // -----------------------------------------------------------------------
    // V-E4 — SPECIFIED_FLOW slots (per-metre-of-edge discharge).
    // Sign convention: outward-positive (matches edge_bc_cum_flux).
    // -----------------------------------------------------------------------

    std::vector<double> edge_bc_flow;

    std::vector<int> edge_bc_flow_tseries;

    std::vector<std::string> edge_bc_flow_tseries_name;
 
    // -----------------------------------------------------------------------
    // V-E5 — RATING_CURVE slot (stage → flow lookup).
    // -----------------------------------------------------------------------

    std::vector<int> edge_bc_rating_curve;

    std::vector<std::string> edge_bc_rating_curve_name;
 
    struct RuntimeOriginal {
        int8_t type;
        double head, flow, slope;
        int stage_ts, flow_ts, rating;
        std::string stage_name, flow_name, rating_name;
    };
    std::map<int, RuntimeOriginal> runtime_original;
    std::map<int, std::string> runtime_owner;
    mutable std::map<int, RuntimeReceipt> receipts;
    void ensureReceipt(int slot, int species) const {
        auto& receipt = receipts[slot];
 
        if (receipt.applied_mass.size() != static_cast<std::size_t>(species)) {
            receipt.requested_mass.assign(species, 0.0);
            receipt.applied_mass.assign(species, 0.0);
        }
    }

    void saveRuntime(int slot) {
        if (runtime_original.count(slot))
            return;
        runtime_original.emplace(
            slot,
            RuntimeOriginal{edge_bc_type[slot], edge_bc_head[slot], edge_bc_flow[slot],
                            edge_bed_slope[slot], edge_bc_tseries[slot], edge_bc_flow_tseries[slot],
                            edge_bc_rating_curve[slot], edge_bc_tseries_name[slot],
                            edge_bc_flow_tseries_name[slot], edge_bc_rating_curve_name[slot]});
    }

    void clearRuntime(int slot) {
        const auto it = runtime_original.find(slot);
        if (it == runtime_original.end())
            return;
        const auto& b = it->second;
        edge_bc_type[slot] = b.type;
        edge_bc_head[slot] = b.head;
        edge_bc_flow[slot] = b.flow;
        edge_bed_slope[slot] = b.slope;
        edge_bc_tseries[slot] = b.stage_ts;
        edge_bc_flow_tseries[slot] = b.flow_ts;
        edge_bc_rating_curve[slot] = b.rating;
        edge_bc_tseries_name[slot] = b.stage_name;
        edge_bc_flow_tseries_name[slot] = b.flow_name;
        edge_bc_rating_curve_name[slot] = b.rating_name;
        runtime_original.erase(it);
        runtime_owner.erase(slot);
    }
 
    // -----------------------------------------------------------------------
    // Lifecycle
    // -----------------------------------------------------------------------

    void resize(int n_edges) {
        runtime_original.clear();
        runtime_owner.clear();
        receipts.clear();
        auto n = static_cast<std::size_t>(n_edges);
        edge_bc_type.assign(n, static_cast<int8_t>(BoundaryType::WALL));
        edge_bed_slope.assign(n, 0.0);
        edge_wall_drag.assign(n, 0.0);
        edge_is_exterior.assign(n, 0);
        edge_bc_head.assign(n, 0.0);
        edge_bc_tseries.assign(n, -1);
        edge_bc_tseries_name.resize(n);
        edge_bc_cum_flux.assign(n, 0.0);
        edge_bc_flow.assign(n, 0.0);
        edge_bc_flow_tseries.assign(n, -1);
        edge_bc_flow_tseries_name.resize(n);
        edge_bc_rating_curve.assign(n, -1);
        edge_bc_rating_curve_name.resize(n);
    }

    int size() const noexcept { return static_cast<int>(edge_bc_type.size()); }
};
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_ENGINE_2D_BOUNDARY_DATA_HPP