ModelHydro.h

#ifndef HYDROBRICKS_MODEL_HYDRO_H
#define HYDROBRICKS_MODEL_HYDRO_H
 
#include <memory>
 
#include "ActionsManager.h"
#include "Includes.h"
#include "Logger.h"
#include "Processor.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 Reset();
 
    void SaveAsInitialState();
 
    bool DumpOutputs(const string& path);
 
    axd GetOutletDischarge() 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) {
        _ownedSubBasin.reset();
        _subBasin = subBasin;
    }
 
    TimeMachine* GetTimeMachine() {
        return &_timer;
    }
 
    Processor* GetProcessor() {
        return &_processor;
    }
 
    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;
 
  protected:
    Processor _processor;
    std::unique_ptr<SubBasin> _ownedSubBasin;  // owning: set only when ModelHydro creates the SubBasin
    SubBasin* _subBasin;                       // non-owning view (points to _ownedSubBasin or an external SubBasin)
    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
 
  private:
    ModelResult InitializeTimeSeries();
 
    ModelResult UpdateForcing();
 
    ModelResult RunSpinup();
 
    ModelResult RewindAfterSpinup();
};
 
#endif  // HYDROBRICKS_MODEL_HYDRO_H