ModelHydro.h

#ifndef HYDROBRICKS_MODEL_HYDRO_H
#define HYDROBRICKS_MODEL_HYDRO_H
 
#include <functional>
#include <memory>
 
#include "ActionsManager.h"
#include "Includes.h"
#include "Logger.h"
#include "Processor.h"
#include "RiverNetwork.h"
#include "SettingsModel.h"
#include "Subbasin.h"
#include "TimeSeries.h"
 
class ModelHydro {
  public:
    ModelHydro(Subbasin* subbasin = nullptr);
 
    virtual ~ModelHydro();
 
    ModelResult InitializeWithBasin(SettingsModel& modelSettings, SettingsBasin& basinSettings);
 
    ModelResult Initialize(SettingsModel& modelSettings, SettingsBasin& basinSettings, bool checkProcesses = true);
 
    void UpdateParameters(SettingsModel& modelSettings);
 
    [[nodiscard]] bool IsValid() const;
 
    void Validate() const;
 
    [[nodiscard]] bool ForcingLoaded() const;
 
    [[nodiscard]] ModelResult Run();
 
    void OpenLog(const string& directory);
 
    void CloseLog();
 
    void Reset();
 
    void SaveAsInitialState();
 
    bool DumpOutputs(const string& path);
 
    axd GetOutletDischarge() const;
 
    [[nodiscard]] axd GetSubbasinDischarge(int subbasinId) const;
 
    [[nodiscard]] int GetSubbasinCount() const;
 
    [[nodiscard]] vecInt GetSubbasinIds() const;
 
    [[nodiscard]] vecInt GetSubbasinDownstreamIds() const;
 
    [[nodiscard]] axd GetSubbasinLocalAreas() const;
 
    [[nodiscard]] axd GetSubbasinDrainedAreas() const;
 
    [[nodiscard]] axd GetReachLengths() const;
 
    [[nodiscard]] axd GetReachSlopes() const;
 
    [[nodiscard]] axd GetReachTravelTimes() const;
 
    [[nodiscard]] vecInt GetReachSubreachCounts() const;
 
    [[nodiscard]] string GetChannelRoutingScheme() const;
 
    [[nodiscard]] HydroUnit* GetHydroUnitById(int id) const;
 
    [[nodiscard]] std::vector<HydroUnit*> GetHydroUnits() const;
 
    [[nodiscard]] double GetTotalOutletDischarge() const;
 
    [[nodiscard]] double GetTotalET() const;
 
    [[nodiscard]] double GetTotalWaterStorageChanges() const;
 
    [[nodiscard]] double GetTotalSnowStorageChanges() const;
 
    /*
     * Get the total change in glacier storage.
     *
     * @return total change in glacier storage.
     */
    [[nodiscard]] double GetTotalGlacierStorageChanges() const;
 
    bool AddTimeSeries(std::unique_ptr<TimeSeries> timeSeries);
 
    bool AddAction(Action* action);
 
    [[nodiscard]] int GetActionCount() const;
 
    [[nodiscard]] int GetSporadicActionItemCount() const;
 
    bool CreateTimeSeries(const string& varName, const axd& time, const axi& ids, const axxd& data);
 
    void ClearTimeSeries();
 
    bool AttachTimeSeriesToHydroUnits();
 
    Subbasin* GetSubbasin() const {
        return _subbasin;  // Return raw pointer from unique_ptr
    }
 
    void SetSubbasin(Subbasin* subbasin) {
        _network.reset();
        _subbasin = subbasin;
    }
 
    RiverNetwork* GetNetwork() const {
        return _network.get();
    }
 
    TimeMachine* GetTimeMachine() {
        return &_timer;
    }
 
    Processor* GetProcessor() {
        return _processors.empty() ? nullptr : _processors.back().get();
    }
 
    Logger* GetLogger() {
        return &_logger;
    }
 
    ActionsManager* GetActionsManager() {
        return &_actionsManager;
    }
 
    [[nodiscard]] axxd GetHydroUnitValues(const string& label) const;
 
    [[nodiscard]] axxd GetHydroUnitFractions(const string& label) const;
 
    [[nodiscard]] vecStr GetRecordedHydroUnitLabels() const;
 
    [[nodiscard]] vecStr GetRecordedHydroUnitFractionLabels() const;
 
    [[nodiscard]] vecInt GetHydroUnitIds() const;
 
    [[nodiscard]] axd GetHydroUnitAreas() const;
 
    [[nodiscard]] string GetHydroUnitLabelBasis(const string& label) const;
 
    [[nodiscard]] axd GetHydroUnitSubbasinFractions() const;
 
  protected:
    std::vector<std::unique_ptr<Processor>> _processors;  // owning: one per subbasin, in processing order
    std::unique_ptr<RiverNetwork> _network;  // owning: set only when ModelHydro builds the network from settings
    Subbasin* _subbasin;                     // non-owning view (the network outlet or an external Subbasin)
    std::vector<Subbasin*> _subbasins;       // non-owning: the subbasins to process, upstream first
    TimeMachine _timer;
    Logger _logger;
    ActionsManager _actionsManager;
    ParametersUpdater _parametersUpdater;
    std::vector<std::unique_ptr<TimeSeries>> _timeSeries;  // owning
    int _spinupSteps = 0;                                  // time steps replayed as spin-up at the start of each run
    LogFile _log;                                          // this model's own log file (see OpenLog)
 
  private:
    [[nodiscard]] axd GetReachProperty(const std::function<double(const Reach&)>& get) const;
 
    [[nodiscard]] std::vector<Subbasin*> CollectSubbasins() const;
 
    bool ProcessTimeStep();
 
    [[nodiscard]] ModelResult CheckTimeStepCompatibility();
 
    ModelResult InitializeTimeSeries();
 
    ModelResult UpdateForcing();
 
    ModelResult RunSpinup();
 
    ModelResult RewindAfterSpinup();
};
 
#endif  // HYDROBRICKS_MODEL_HYDRO_H