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;
 
    std::unordered_map<int, std::string> groups;
    if (pending)
        for (const auto& p : *pending) groups[MeshData::slot(p.tri,p.edge)] = p.group;
    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 && boundary->edge_wall_drag[idx] == 0 &&
            (groups.find(idx) == groups.end() || groups.at(idx).empty()))
            continue;
 
        PendingBoundaryRow r;
        r.tri = MeshData::slot_cell(idx);
        r.edge = MeshData::slot_local(idx);
        r.bc_type = static_cast<int>(type);
        if (auto it = groups.find(idx); it != groups.end()) r.group = it->second;
 
        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:
            r.param1 = boundary->edge_wall_drag[idx];
            break;
        }
        rows.push_back(std::move(r));
    }
 
    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