Subbasin.h

#ifndef HYDROBRICKS_SUBBASIN_H
#define HYDROBRICKS_SUBBASIN_H
 
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "Connector.h"
#include "HydroUnit.h"
#include "HydroUnitProperty.h"
#include "Includes.h"
#include "SettingsBasin.h"
#include "TimeMachine.h"
 
class Reach;
 
class Subbasin {
  public:
    Subbasin();
 
    virtual ~Subbasin();
 
    [[nodiscard]] ModelResult Initialize(SettingsBasin& basinSettings);
 
    HydroUnit* AddHydroUnitFromSettings(HydroUnitSettings& unitSettings);
 
    void SetNetworkProperties(const SubbasinSettings& subbasinSettings);
 
    void SetId(int id) {
        _id = id;
    }
 
    [[nodiscard]] int GetId() const {
        return _id;
    }
 
    void SetDownstreamId(int id) {
        _downstreamId = id;
    }
 
    [[nodiscard]] int GetDownstreamId() const {
        return _downstreamId;
    }
 
    [[nodiscard]] bool IsTerminal() const {
        return _downstreamId == 0;
    }
 
    void SetName(const string& name) {
        _name = name;
    }
 
    [[nodiscard]] const string& GetName() const {
        return _name;
    }
 
    void SetStructureId(int structureId) {
        _structureId = structureId;
    }
 
    [[nodiscard]] int GetStructureId() const {
        return _structureId;
    }
 
    [[nodiscard]] double GetLocalArea() const {
        return _area;
    }
 
    void SetDrainedArea(double area) {
        _drainedArea = area;
    }
 
    [[nodiscard]] double GetDrainedArea() const {
        return _drainedArea;
    }
 
    void SetHasUpstream(bool value) {
        _hasUpstream = value;
    }
 
    [[nodiscard]] bool HasUpstream() const {
        return _hasUpstream;
    }
 
    void SetReach(Reach* reach) {
        _reach = reach;
    }
 
    [[nodiscard]] Reach* GetReach() const {
        return _reach;
    }
 
    void SetInflowVolume(double volume) {
        _inflowVolume = volume;
    }
 
    [[nodiscard]] double GetInflowVolume() const {
        return _inflowVolume;
    }
 
    [[nodiscard]] double GetLocalOutlet() const {
        return _outletTotal;
    }
 
    [[nodiscard]] double GetOutletVolume() const {
        return _outletVolume;
    }
 
    [[nodiscard]] double GetOutletDischarge() const {
        return _outletDischarge;
    }
 
    [[nodiscard]] bool HasHydroUnit(int id) const {
        return _hydroUnitMap.contains(id);
    }
 
    [[nodiscard]] bool HasProperty(std::string_view name) const;
 
    [[nodiscard]] double GetPropertyDouble(std::string_view name, std::string_view unit = "") const;
 
    [[nodiscard]] string GetPropertyString(std::string_view name) const;
 
    void BuildBasin(SettingsBasin& basinSettings);
 
    void ReserveHydroUnits(size_t count) {
        _hydroUnits.reserve(_hydroUnits.size() + count);
    }
 
    void ReserveBricks(size_t count) {
        _bricks.reserve(_bricks.size() + count);
    }
 
    void ReserveSplitters(size_t count) {
        _splitters.reserve(_splitters.size() + count);
    }
 
    void ReserveInputConnectors(size_t count) {
        _inConnectors.reserve(_inConnectors.size() + count);
    }
 
    void ReserveOutputConnectors(size_t count) {
        _outConnectors.reserve(_outConnectors.size() + count);
    }
 
    void ReserveOutletFluxes(size_t count) {
        _outletFluxes.reserve(_outletFluxes.size() + count);
    }
 
    void ReserveLateralConnectionsForUnits(SettingsBasin& basinSettings);
 
    [[nodiscard]] ModelResult AssignFractions(SettingsBasin& basinSettings);
 
    void Reset();
 
    void SaveAsInitialState();
 
    void RestoreInitialAreaFractions();
 
    [[nodiscard]] bool IsValid(bool checkProcesses = true) const;
 
    void Validate() const;
 
    void AddBrick(std::unique_ptr<Brick> brick);
 
    void AddSplitter(std::unique_ptr<Splitter> splitter);
 
    void AddHydroUnit(std::unique_ptr<HydroUnit> unit);
 
    [[nodiscard]] int GetHydroUnitCount() const;
 
    void ResetForcingUpdates();
 
    [[nodiscard]] HydroUnit* GetHydroUnit(size_t index) const;
 
    [[nodiscard]] bool HasHydroUnits() const noexcept {
        return !_hydroUnits.empty();
    }
 
    [[nodiscard]] HydroUnit* GetHydroUnitById(int id) const;
 
    [[nodiscard]] vecInt GetHydroUnitIds() const;
 
    [[nodiscard]] vecDouble GetHydroUnitAreas() const;
 
    [[nodiscard]] vecInt GetHydroUnitStructureIds() const;
 
    [[nodiscard]] int GetBrickCount() const;
 
    [[nodiscard]] int GetSplitterCount() const;
 
    [[nodiscard]] Brick* GetBrick(size_t index) const;
 
    [[nodiscard]] bool HasBrick(std::string_view name) const;
 
    [[nodiscard]] Brick* GetBrick(std::string_view name) const;
 
    [[nodiscard]] Splitter* GetSplitter(size_t index) const;
 
    [[nodiscard]] bool HasSplitter(std::string_view name) const;
 
    [[nodiscard]] Splitter* GetSplitter(std::string_view name) const;
 
    [[nodiscard]] bool HasIncomingFlow() const;
 
    void AddInputConnector(Connector* connector);
 
    void AddOutputConnector(Connector* connector);
 
    void AttachOutletFlux(Flux* pFlux);
 
    double* GetValuePointer(std::string_view name);
 
    [[nodiscard]] bool ComputeOutletDischarge(double timeStepInDays);
 
    [[nodiscard]] double GetArea() const {
        return _area;
    }
 
  protected:
    int _id = 1;
    int _downstreamId = 0;  // 0: terminal outlet of the network
    string _name;
    int _structureId = 1;         // model-structure variant of the subbasin-level components
    double _area;                 // m2, own hydro units
    double _drainedArea = 0;      // m2, own + upstream (set by the network)
    bool _hasUpstream = false;    // other subbasins drain into this one
    Reach* _reach = nullptr;      // non-owning: owned by the river network
    double _outletTotal;          // mm over the local area, own runoff
    double _inflowVolume = 0;     // m3 per step, routed from upstream
    double _outletVolume = 0;     // m3 per step, at the outlet
    double _outletDischarge = 0;  // mm over the drained area, at the outlet
    double _reachInflow = 0;      // mm over the drained area: the volume entering the reach from upstream
    double _reachOutflow = 0;     // mm over the drained area: the routed volume reaching the outlet
    double _reachStorage = 0;     // mm over the drained area: the volume in transit in the reach
    std::vector<std::unique_ptr<HydroUnitProperty>> _properties;  // owning
    std::vector<std::unique_ptr<Brick>> _bricks;                  // owning: Subbasin-level bricks
    std::unordered_map<string, Brick*> _brickMap;                 // non-owning views into _bricks
    std::vector<std::unique_ptr<Splitter>> _splitters;            // owning: Subbasin-level splitters
    std::unordered_map<string, Splitter*> _splitterMap;           // non-owning views into _splitters
    std::vector<std::unique_ptr<HydroUnit>> _hydroUnits;          // owning
    std::unordered_map<int, HydroUnit*> _hydroUnitMap;            // non-owning views into _hydroUnits
    std::vector<Connector*> _inConnectors;                        // non-owning: lifetime managed externally
    std::vector<Connector*> _outConnectors;                       // non-owning: lifetime managed externally
    std::vector<Flux*> _outletFluxes;                             // non-owning: lifetime managed by process owners
};
 
#endif