SubBasin.h

#ifndef HYDROBRICKS_SUBBASIN_H
#define HYDROBRICKS_SUBBASIN_H
 
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "Connector.h"
#include "HydroUnit.h"
#include "Includes.h"
#include "SettingsBasin.h"
#include "TimeMachine.h"
 
class SubBasin {
  public:
    SubBasin();
 
    virtual ~SubBasin();
 
    [[nodiscard]] ModelResult Initialize(SettingsBasin& basinSettings);
 
    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();
 
    [[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]] 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();
 
    [[nodiscard]] double GetArea() const {
        return _area;
    }
 
  protected:
    double _area;  // m2
    double _outletTotal;
    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