SourceWaterDeliveryBridge.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Caleb Buahin

 
#pragma once
#include "SourceWaterDriver.hpp"
#include <cstdint>
#include <optional>
 
namespace openswmm::runoff {
struct QueuedSourceDelivery {
    uint64_t ordinal = 0;
    double available = 0;      // accepted receiving boundary, seconds
    SourceWaterDelivery water; // original completed source interval and ft3
};
struct SourceNodeDelivery {
    double runoff = 0, drain = 0; // ft3, kept separate for hydraulic continuity
    double rate = 0;              // total ft3/s over the staged receiving interval
};

class SourceWaterDeliveryBridge {
public:
    std::string initialize(const SourceWaterDriver& source);
    bool ownsSubcatch(int source) const;
    const std::vector<int>& sourceGroups() const { return source_groups_; }
    std::string validateReceiver(const SimulationContext& context) const;
    std::string capture(const SourceWaterDriver& source, double accepted_end);
    std::string stage(double start, double end);
    std::string commit();
    void cancel() { trial_.reset(); }
    const std::vector<SourceNodeDelivery>& receipts() const;
    const std::vector<QueuedSourceDelivery>& pending() const { return state_.pending; }
    const std::vector<SourceNodeDelivery>& received() const { return state_.received; }
    const std::vector<SourceNodeDelivery>& delivered() const { return state_.delivered; }
    const std::vector<SourceNodeDelivery>& lastReceipts() const { return state_.last; }
    double lastStart() const { return state_.last_start; }
    double receiverEnd() const { return state_.receiver_end; }
    uint64_t capturedCount() const { return state_.count; }
    void checkpoint(detail::CompletedSourceArchive& archive, bool model,
                    const SourceWaterDriver& source);
 
private:
    struct State {
        uint64_t count = 0, digest = 14695981039346656037ULL;
        double receiver_end = 0;
        std::vector<double> source_ends;
        std::vector<QueuedSourceDelivery> pending;
        std::vector<SourceNodeDelivery> received, delivered, last;
        uint64_t last_begin = 0;
        double last_start = 0;
    } state_;
    struct Trial {
        double end = 0;
        std::vector<SourceNodeDelivery> receipts, delivered;
    };
    bool initialized_ = false;
    std::string source_model_;
    std::vector<std::string> node_names_;
    std::vector<int> source_groups_;
    std::optional<Trial> trial_;
    void validate(const State& state, const SourceWaterDriver& source) const;
};
}