Serialize2D.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_2D_SERIALIZE_2D_HPP
#define OPENSWMM_ENGINE_2D_SERIALIZE_2D_HPP
 
#include "MeshData.hpp"
#include "BoundaryData.hpp"
#include "PendingRows2D.hpp"
 
#include <algorithm>
#include <cstdint>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace openswmm::twoD {

inline std::vector<PendingBoundaryRow> collectBCRows(
    const std::vector<PendingBoundaryRow>* pending,
    const BoundaryData* boundary,
    bool drained) {
 
    if (!drained) {
        if (pending && !pending->empty()) return *pending;
        // Not drained and no pending rows: nothing has been authored yet
        // (boundary, if sized at all, holds only WALL defaults).
    }
 
    std::vector<PendingBoundaryRow> rows;
    if (!boundary) return rows;
 
    const int n = boundary->size();
    for (int idx = 0; idx < n; ++idx) {
        const auto type =
            static_cast<BoundaryType>(boundary->edge_bc_type[idx]);
        if (type == BoundaryType::WALL) continue;
 
        PendingBoundaryRow r;
        r.tri     = idx / 3;
        r.edge    = idx % 3;
        r.bc_type = static_cast<int>(type);
 
        switch (type) {
        case BoundaryType::NORMAL_FLOW:
            r.param1 = boundary->edge_bed_slope[idx];
            break;
        case BoundaryType::SPECIFIED_STAGE:
            if (!boundary->edge_bc_tseries_name[idx].empty())
                r.name = boundary->edge_bc_tseries_name[idx];
            else
                r.param1 = boundary->edge_bc_head[idx];
            break;
        case BoundaryType::SPECIFIED_FLOW:
            if (!boundary->edge_bc_flow_tseries_name[idx].empty())
                r.name = boundary->edge_bc_flow_tseries_name[idx];
            else
                r.param1 = boundary->edge_bc_flow[idx];
            break;
        case BoundaryType::RATING_CURVE:
            r.name = boundary->edge_bc_rating_curve_name[idx];
            break;
        case BoundaryType::WALL:
            break;
        }
        rows.push_back(std::move(r));
    }
 
    // Re-attach the authored GROUP labels (organizational metadata that
    // BoundaryData does not carry) from the retained pending rows.
    if (pending && !pending->empty() && !rows.empty()) {
        std::unordered_map<int, const std::string*> groups;
        groups.reserve(pending->size());
        for (const auto& p : *pending) {
            if (!p.group.empty()) groups[p.tri * 3 + p.edge] = &p.group;
        }
        if (!groups.empty()) {
            for (auto& r : rows) {
                auto it = groups.find(r.tri * 3 + r.edge);
                if (it != groups.end()) r.group = *it->second;
            }
        }
    }
    return rows;
}

inline std::vector<PendingEdgeConveyanceRow> collectConveyanceRows(
    const std::vector<PendingEdgeConveyanceRow>* pending,
    const MeshData* mesh,
    bool drained) {
 
    if (!drained && pending && !pending->empty()) return *pending;
 
    std::vector<PendingEdgeConveyanceRow> rows;
    if (!mesh) return rows;
 
    const int nt = mesh->n_triangles();
    if (nt < 1 ||
        mesh->edge_conveyance.size() < static_cast<std::size_t>(nt) * 3)
        return rows;
 
    std::unordered_set<std::int64_t> seen;
    for (int t = 0; t < nt; ++t) {
        const int v[3] = { mesh->tri_v0[t], mesh->tri_v1[t], mesh->tri_v2[t] };
        for (int e = 0; e < 3; ++e) {
            const double k = mesh->edge_conveyance[t * 3 + e];
            if (k == 1.0) continue;
            const int va = std::min(v[(e + 1) % 3], v[(e + 2) % 3]);
            const int vb = std::max(v[(e + 1) % 3], v[(e + 2) % 3]);
            const std::int64_t key =
                (static_cast<std::int64_t>(va) << 32)
                | (static_cast<std::int64_t>(vb) & 0xFFFFFFFFLL);
            if (!seen.insert(key).second) continue;
            rows.push_back(PendingEdgeConveyanceRow{va, vb, k});
        }
    }
    return rows;
}
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_ENGINE_2D_SERIALIZE_2D_HPP