NodeSubtypes.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_NODE_SUBTYPES_HPP
#define OPENSWMM_ENGINE_NODE_SUBTYPES_HPP
 
#include "LidNodeData.hpp"
#include <algorithm>
#include <vector>
#include <cstdint>
#include <string>
 
#include "NodeData.hpp"
 
namespace openswmm {
 
// ============================================================================
// StorageData — side-table for STORAGE nodes
// ============================================================================

struct StorageData {
    std::vector<LidNodeConfig> lid;
    std::vector<LidNodeState> lid_state;
    std::vector<int> node_idx;

    std::vector<int> curve;
    std::vector<std::string> curve_name;
    std::vector<StorageShape> shape;
    std::vector<double> a;
    std::vector<double> b;
    std::vector<double> c;
    std::vector<double> p1;
    std::vector<double> p2;
    std::vector<double> p3;
    std::vector<double> seep_rate;
    std::vector<double> evap_frac;
    std::vector<double> evap_loss;
    std::vector<double> exfil_loss;
    std::vector<double> exfil_rate;
    std::vector<double> exfil_suction;
    std::vector<double> exfil_ksat;
    std::vector<double> exfil_imd;

    int count() const noexcept { return static_cast<int>(node_idx.size()); }

    void clear() noexcept {
        node_idx.clear();
        curve.clear();
        curve_name.clear();
        shape.clear();
        a.clear();
        b.clear();
        c.clear();
        p1.clear();
        p2.clear();
        p3.clear();
        seep_rate.clear();
        evap_frac.clear();
        evap_loss.clear();
        exfil_loss.clear();
        exfil_rate.clear();
        exfil_suction.clear();
        exfil_ksat.clear();
        exfil_imd.clear();
        lid.clear();
        lid_state.clear();
    }

    void reserve(int n) {
        const auto un = static_cast<std::size_t>(n);
        node_idx.reserve(un);
        curve.reserve(un);
        curve_name.reserve(un);
        shape.reserve(un);
        a.reserve(un);
        b.reserve(un);
        c.reserve(un);
        p1.reserve(un);
        p2.reserve(un);
        p3.reserve(un);
        seep_rate.reserve(un);
        evap_frac.reserve(un);
        evap_loss.reserve(un);
        exfil_loss.reserve(un);
        exfil_rate.reserve(un);
        exfil_suction.reserve(un);
        exfil_ksat.reserve(un);
        exfil_imd.reserve(un);
        lid.reserve(un);
        lid_state.reserve(un);
    }

    int add_default(int i) {
        const auto p = static_cast<std::ptrdiff_t>(
            std::lower_bound(node_idx.begin(), node_idx.end(), i) - node_idx.begin());
        node_idx.insert(node_idx.begin() + p, i);
        curve.insert(curve.begin() + p, -1);
        curve_name.insert(curve_name.begin() + p, std::string{});
        // FUNCTIONAL is the historical default for a curve-less storage row: it is what
        // `curve < 0` has always meant, so existing callers see no behaviour change.
        shape.insert(shape.begin() + p, StorageShape::FUNCTIONAL);
        a.insert(a.begin() + p, 0.0);
        b.insert(b.begin() + p, 0.0);
        c.insert(c.begin() + p, 0.0);
        p1.insert(p1.begin() + p, 0.0);
        p2.insert(p2.begin() + p, 0.0);
        p3.insert(p3.begin() + p, 0.0);
        seep_rate.insert(seep_rate.begin() + p, 0.0);
        evap_frac.insert(evap_frac.begin() + p, 0.0);
        evap_loss.insert(evap_loss.begin() + p, 0.0);
        exfil_loss.insert(exfil_loss.begin() + p, 0.0);
        exfil_rate.insert(exfil_rate.begin() + p, 0.0);
        exfil_suction.insert(exfil_suction.begin() + p, 0.0);
        exfil_ksat.insert(exfil_ksat.begin() + p, 0.0);
        exfil_imd.insert(exfil_imd.begin() + p, 0.0);
        lid.insert(lid.begin() + p, LidNodeConfig{});
        lid_state.insert(lid_state.begin() + p, LidNodeState{});
        return static_cast<int>(p);
    }

    void erase_at(int r) {
        const auto p = static_cast<std::ptrdiff_t>(r);
        node_idx.erase(node_idx.begin() + p);
        curve.erase(curve.begin() + p);
        curve_name.erase(curve_name.begin() + p);
        shape.erase(shape.begin() + p);
        a.erase(a.begin() + p);
        b.erase(b.begin() + p);
        c.erase(c.begin() + p);
        p1.erase(p1.begin() + p);
        p2.erase(p2.begin() + p);
        p3.erase(p3.begin() + p);
        seep_rate.erase(seep_rate.begin() + p);
        evap_frac.erase(evap_frac.begin() + p);
        evap_loss.erase(evap_loss.begin() + p);
        exfil_loss.erase(exfil_loss.begin() + p);
        exfil_rate.erase(exfil_rate.begin() + p);
        exfil_suction.erase(exfil_suction.begin() + p);
        exfil_ksat.erase(exfil_ksat.begin() + p);
        exfil_imd.erase(exfil_imd.begin() + p);
        lid.erase(lid.begin() + p);
        lid_state.erase(lid_state.begin() + p);
    }
};
 
// ============================================================================
// OutfallData — side-table for OUTFALL nodes
// ============================================================================

struct OutfallData {
    std::vector<int> node_idx;

    std::vector<OutfallType> bc_type;
    std::vector<double> param;
    std::vector<std::string> param_name;
    std::vector<uint8_t> has_flap_gate;
    std::vector<int> route_to;
    std::vector<int> link_idx;
    std::vector<double> link_offset;
    std::vector<double> head_2d;
    std::vector<double> ramp_2d;

    int count() const noexcept { return static_cast<int>(node_idx.size()); }

    void clear() noexcept {
        node_idx.clear();
        bc_type.clear();
        param.clear();
        param_name.clear();
        has_flap_gate.clear();
        route_to.clear();
        link_idx.clear();
        link_offset.clear();
        head_2d.clear();
        ramp_2d.clear();
    }

    void reserve(int n) {
        const auto un = static_cast<std::size_t>(n);
        node_idx.reserve(un);
        bc_type.reserve(un);
        param.reserve(un);
        param_name.reserve(un);
        has_flap_gate.reserve(un);
        route_to.reserve(un);
        link_idx.reserve(un);
        link_offset.reserve(un);
        head_2d.reserve(un);
        ramp_2d.reserve(un);
    }

    int add_default(int i) {
        const auto p = static_cast<std::ptrdiff_t>(
            std::lower_bound(node_idx.begin(), node_idx.end(), i) - node_idx.begin());
        node_idx.insert(node_idx.begin() + p, i);
        bc_type.insert(bc_type.begin() + p, OutfallType::FREE);
        param.insert(param.begin() + p, 0.0);
        param_name.insert(param_name.begin() + p, std::string{});
        has_flap_gate.insert(has_flap_gate.begin() + p, uint8_t{0});
        route_to.insert(route_to.begin() + p, -1);
        link_idx.insert(link_idx.begin() + p, -1);
        link_offset.insert(link_offset.begin() + p, 0.0);
        head_2d.insert(head_2d.begin() + p, -1.0e30);
        ramp_2d.insert(ramp_2d.begin() + p, 0.0);
        return static_cast<int>(p);
    }

    void erase_at(int r) {
        const auto p = static_cast<std::ptrdiff_t>(r);
        node_idx.erase(node_idx.begin() + p);
        bc_type.erase(bc_type.begin() + p);
        param.erase(param.begin() + p);
        param_name.erase(param_name.begin() + p);
        has_flap_gate.erase(has_flap_gate.begin() + p);
        route_to.erase(route_to.begin() + p);
        link_idx.erase(link_idx.begin() + p);
        link_offset.erase(link_offset.begin() + p);
        head_2d.erase(head_2d.begin() + p);
        ramp_2d.erase(ramp_2d.begin() + p);
    }
};
 
// ============================================================================
// DividerData — side-table for DIVIDER nodes
// ============================================================================

struct DividerData {
    std::vector<int> node_idx;

    std::vector<DividerType> method;
    std::vector<double> cutoff;
    std::vector<double> cd;
    std::vector<double> max_depth;
    std::vector<int> curve;
    std::vector<int> link;
    std::vector<std::string> link_name;
    std::vector<std::string> curve_name;

    int count() const noexcept { return static_cast<int>(node_idx.size()); }

    void clear() noexcept {
        node_idx.clear();
        method.clear();
        cutoff.clear();
        cd.clear();
        max_depth.clear();
        curve.clear();
        link.clear();
        link_name.clear();
        curve_name.clear();
    }

    void reserve(int n) {
        const auto un = static_cast<std::size_t>(n);
        node_idx.reserve(un);
        method.reserve(un);
        cutoff.reserve(un);
        cd.reserve(un);
        max_depth.reserve(un);
        curve.reserve(un);
        link.reserve(un);
        link_name.reserve(un);
        curve_name.reserve(un);
    }

    int add_default(int i) {
        const auto p = static_cast<std::ptrdiff_t>(
            std::lower_bound(node_idx.begin(), node_idx.end(), i) - node_idx.begin());
        node_idx.insert(node_idx.begin() + p, i);
        method.insert(method.begin() + p, DividerType::CUTOFF);
        cutoff.insert(cutoff.begin() + p, 0.0);
        cd.insert(cd.begin() + p, 0.0);
        max_depth.insert(max_depth.begin() + p, 0.0);
        curve.insert(curve.begin() + p, -1);
        link.insert(link.begin() + p, -1);
        link_name.insert(link_name.begin() + p, std::string{});
        curve_name.insert(curve_name.begin() + p, std::string{});
        return static_cast<int>(p);
    }

    void erase_at(int r) {
        const auto p = static_cast<std::ptrdiff_t>(r);
        node_idx.erase(node_idx.begin() + p);
        method.erase(method.begin() + p);
        cutoff.erase(cutoff.begin() + p);
        cd.erase(cd.begin() + p);
        max_depth.erase(max_depth.begin() + p);
        curve.erase(curve.begin() + p);
        link.erase(link.begin() + p);
        link_name.erase(link_name.begin() + p);
        curve_name.erase(curve_name.begin() + p);
    }
};
 
// ============================================================================
// NodeSubtypes — container + reverse map + build/verify
// ============================================================================

struct NodeSubtypes {
    StorageData storages;
    OutfallData outfalls;
    DividerData dividers;

    std::vector<int> subtype_row;

    void clear() noexcept {
        storages.clear();
        outfalls.clear();
        dividers.clear();
        subtype_row.clear();
    }

    void rebuild_index(int n_nodes) {
        subtype_row.assign(static_cast<std::size_t>(n_nodes), -1);
        for (int r = 0; r < storages.count(); ++r)
            subtype_row[static_cast<std::size_t>(storages.node_idx[static_cast<std::size_t>(r)])] =
                r;
        for (int r = 0; r < outfalls.count(); ++r)
            subtype_row[static_cast<std::size_t>(outfalls.node_idx[static_cast<std::size_t>(r)])] =
                r;
        for (int r = 0; r < dividers.count(); ++r)
            subtype_row[static_cast<std::size_t>(dividers.node_idx[static_cast<std::size_t>(r)])] =
                r;
    }

    int set_node_type(NodeData& nodes, int i, NodeType t) {
        const auto ui = static_cast<std::size_t>(i);
        if (i >= static_cast<int>(subtype_row.size()))
            subtype_row.resize(static_cast<std::size_t>(i) + 1, -1);
 
        // Contexts sized column by column may omit storage_area; unsized means no chamber.
        if (t != NodeType::JUNCTION && ui < nodes.storage_area.size())
            nodes.storage_area[ui] = 0.0;
        const NodeType old = nodes.type[ui];
        const int existing = subtype_row[ui];
        if (old == t && existing >= 0)
            return existing; // already this subtype with a row — idempotent.
 
        bool shifted = false;
        if (existing >= 0) { // remove the old subtype row (real re-type/convert).
            switch (old) {
            case NodeType::STORAGE:
                storages.erase_at(existing);
                break;
            case NodeType::OUTFALL:
                outfalls.erase_at(existing);
                break;
            case NodeType::DIVIDER:
                dividers.erase_at(existing);
                break;
            default:
                break;
            }
            shifted = true;
        }
 
        nodes.type[ui] = t;
 
        int row = -1;
        switch (t) {
        case NodeType::STORAGE:
            row = storages.add_default(i);
            if (row != storages.count() - 1)
                shifted = true;
            break;
        case NodeType::OUTFALL:
            row = outfalls.add_default(i);
            if (row != outfalls.count() - 1)
                shifted = true;
            break;
        case NodeType::DIVIDER:
            row = dividers.add_default(i);
            if (row != dividers.count() - 1)
                shifted = true;
            break;
        case NodeType::JUNCTION:
        default:
            break; // no subtype row
        }
 
        if (shifted) {
            rebuild_index(nodes.count());
            return (t == NodeType::JUNCTION) ? -1 : subtype_row[ui];
        }
        subtype_row[ui] = row; // O(1) ascending-parse / end-insert path
        return row;
    }

    void erase_node(int i, int n_after) {
        // Erase the row whose node_idx == i (in whichever table holds it).
        auto drop = [i](auto& tbl) -> bool {
            for (int r = 0; r < tbl.count(); ++r)
                if (tbl.node_idx[static_cast<std::size_t>(r)] == i) {
                    tbl.erase_at(r);
                    return true;
                }
            return false;
        };
        drop(storages) || drop(outfalls) || drop(dividers);
 
        auto shift = [i](std::vector<int>& keys) {
            for (auto& k : keys)
                if (k > i)
                    --k;
        };
        shift(storages.node_idx);
        shift(outfalls.node_idx);
        shift(dividers.node_idx);
 
        rebuild_index(n_after);
    }

    int storage_row(int i) const noexcept {
        if (i >= 0 && i < static_cast<int>(subtype_row.size())) {
            const int r = subtype_row[static_cast<std::size_t>(i)];
            if (r >= 0 && r < storages.count() &&
                storages.node_idx[static_cast<std::size_t>(r)] == i)
                return r;
        }
        return -1;
    }

    int outfall_row(int i) const noexcept {
        if (i >= 0 && i < static_cast<int>(subtype_row.size())) {
            const int r = subtype_row[static_cast<std::size_t>(i)];
            if (r >= 0 && r < outfalls.count() &&
                outfalls.node_idx[static_cast<std::size_t>(r)] == i)
                return r;
        }
        return -1;
    }

    int divider_row(int i) const noexcept {
        if (i >= 0 && i < static_cast<int>(subtype_row.size())) {
            const int r = subtype_row[static_cast<std::size_t>(i)];
            if (r >= 0 && r < dividers.count() &&
                dividers.node_idx[static_cast<std::size_t>(r)] == i)
                return r;
        }
        return -1;
    }
};
 
} // namespace openswmm
 
#endif // OPENSWMM_ENGINE_NODE_SUBTYPES_HPP