NodeSubtypes.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_NODE_SUBTYPES_HPP
#define OPENSWMM_ENGINE_NODE_SUBTYPES_HPP
 
#include <algorithm>
#include <vector>
#include <cstdint>
#include <string>
 
#include "NodeData.hpp"
 
namespace openswmm {
 
// ============================================================================
// StorageData — side-table for STORAGE nodes
// ============================================================================

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

    std::vector<int>         curve;
    std::vector<std::string> curve_name;
    std::vector<double>      a;
    std::vector<double>      b;
    std::vector<double>      c;
    std::vector<double>      seep_rate;
    std::vector<double>      evap_frac;
    std::vector<double>      evap_loss;
    std::vector<double>      exfil_loss;
    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();
        a.clear(); b.clear(); c.clear();
        seep_rate.clear(); evap_frac.clear(); evap_loss.clear(); exfil_loss.clear();
        exfil_suction.clear(); exfil_ksat.clear(); exfil_imd.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);
        a.reserve(un); b.reserve(un); c.reserve(un);
        seep_rate.reserve(un); evap_frac.reserve(un);
        evap_loss.reserve(un); exfil_loss.reserve(un);
        exfil_suction.reserve(un); exfil_ksat.reserve(un); exfil_imd.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{});
        a.insert(a.begin() + p, 0.0);
        b.insert(b.begin() + p, 0.0);
        c.insert(c.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_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);
        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);
        a.erase(a.begin() + p);
        b.erase(b.begin() + p);
        c.erase(c.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_suction.erase(exfil_suction.begin() + p);
        exfil_ksat.erase(exfil_ksat.begin() + p);
        exfil_imd.erase(exfil_imd.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<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();
        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);
        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);
        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);
        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);
 
        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