RiverNetwork.h

#ifndef HYDROBRICKS_RIVER_NETWORK_H
#define HYDROBRICKS_RIVER_NETWORK_H
 
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "Includes.h"
#include "Reach.h"
#include "SettingsBasin.h"
#include "SettingsModel.h"
#include "Subbasin.h"
 
class RiverNetwork {
  public:
    RiverNetwork() = default;
 
    virtual ~RiverNetwork() = default;
 
    [[nodiscard]] ModelResult Initialize(SettingsBasin& basinSettings);
 
    [[nodiscard]] int GetSubbasinCount() const {
        return static_cast<int>(_subbasins.size());
    }
 
    [[nodiscard]] Subbasin* GetSubbasin(size_t index) const;
 
    [[nodiscard]] Subbasin* GetSubbasinById(int id) const;
 
    [[nodiscard]] Subbasin* GetOutlet() const {
        return _outlet;
    }
 
    [[nodiscard]] const std::vector<Subbasin*>& GetProcessingOrder() const {
        return _order;
    }
 
    [[nodiscard]] const std::vector<Subbasin*>& GetUpstreamSubbasins(const Subbasin* subbasin) const;
 
    void TransferInflow(Subbasin* subbasin, double timeStepInDays);
 
    void SetChannelRouting(const ChannelRoutingSettings& settings);
 
    [[nodiscard]] ModelResult AssignFractions(SettingsBasin& basinSettings);
 
    void Reset();
 
    void SaveAsInitialState();
 
    [[nodiscard]] Reach* GetReach(size_t index) const;
 
    [[nodiscard]] HydroUnit* GetHydroUnitById(int id) const;
 
    [[nodiscard]] int GetHydroUnitCount() const;
 
    [[nodiscard]] vecInt GetSubbasinIds() const;
 
    [[nodiscard]] vecInt GetSubbasinDownstreamIds() const;
 
    [[nodiscard]] vecDouble GetSubbasinLocalAreas() const;
 
    [[nodiscard]] vecDouble GetSubbasinDrainedAreas() const;
 
    [[nodiscard]] double GetTotalArea() const;
 
  protected:
    std::vector<std::unique_ptr<Subbasin>> _subbasins;  // owning, in declaration order
    std::unordered_map<int, Subbasin*> _subbasinMap;    // non-owning views into _subbasins
    std::unordered_map<int, HydroUnit*> _hydroUnitMap;  // non-owning views into the subbasins' units
    std::vector<Subbasin*> _order;                      // non-owning, upstream first
    Subbasin* _outlet = nullptr;                        // non-owning
    std::vector<std::unique_ptr<Reach>> _reaches;       // owning, aligned with _subbasins
    std::unordered_map<const Subbasin*, std::vector<Subbasin*>> _upstream;  // non-owning views
 
  private:
    void Build(SettingsBasin& basinSettings);
 
    void BuildProcessingOrder();
 
    void ComputeDrainedAreas();
 
    void BuildReaches();
};
 
#endif  // HYDROBRICKS_RIVER_NETWORK_H