Serialize2D.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_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,
    double flow_to_si_applied = 1.0) {
 
    const double flow_to_display =
        (flow_to_si_applied > 0.0) ? 1.0 / flow_to_si_applied : 1.0;
 
    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     = MeshData::slot_cell(idx);
        r.edge    = MeshData::slot_local(idx);
        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] * flow_to_display;
            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[MeshData::slot(p.tri, p.edge)] = &p.group;
        }
        if (!groups.empty()) {
            for (auto& r : rows) {
                auto it = groups.find(MeshData::slot(r.tri, 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>(mesh->n_edge_slots()))
        return rows;
 
    std::unordered_set<std::int64_t> seen;
    for (int t = 0; t < nt; ++t) {
        const int nvc = mesh->cell_vertex_count(t);
        for (int e = 0; e < nvc; ++e) {
            const double k = mesh->edge_conveyance[MeshData::slot(t, e)];
            if (k == 1.0) continue;
            int ea, eb;
            mesh->cell_edge_vertices(t, e, ea, eb);
            const int va = std::min(ea, eb);
            const int vb = std::max(ea, eb);
            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