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();
 
    bool InitializeWithBasin(SettingsModel& modelSettings, SettingsBasin& basinSettings);
 
    bool Initialize(SettingsModel& modelSettings, SettingsBasin& basinSettings, bool checkProcesses = true);
 
    void UpdateParameters(SettingsModel& modelSettings);
 
    [[nodiscard]] bool IsValid() const;
 
    void Validate() const;
 
    [[nodiscard]] bool ForcingLoaded();
 
    [[nodiscard]] bool Run();
 
    void Reset();
 
    void SaveAsInitialState();
 
    bool DumpOutputs(const string& path);
 
    axd GetOutletDischarge() const;
 
    double GetTotalOutletDischarge() const;
 
    double GetTotalET() const;
 
    double GetTotalWaterStorageChanges() const;
 
    double GetTotalSnowStorageChanges() const;
 
    /*
     * Get the total change in glacier storage.
     *
     * @return total change in glacier storage.
     */
    double GetTotalGlacierStorageChanges() const;
 
    bool AddTimeSeries(std::unique_ptr<TimeSeries> timeSeries);
 
    bool AddAction(Action* action);
 
    int GetActionCount() const;
 
    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) {
        delete _subBasin;
        _subBasin = nullptr;
        _subBasin = subBasin;
    }
 
    TimeMachine* GetTimeMachine() {
        return &_timer;
    }
 
    Processor* GetProcessor() {
        return &_processor;
    }
 
    Logger* GetLogger() {
        return &_logger;
    }
 
    ActionsManager* GetActionsManager() {
        return &_actionsManager;
    }
 
  protected:
    Processor _processor;
    SubBasin* _subBasin;  // owning, but not a unique pointer (can be null)
    TimeMachine _timer;
    Logger _logger;
    ActionsManager _actionsManager;
    ParametersUpdater _parametersUpdater;
    std::vector<std::unique_ptr<TimeSeries>> _timeSeries;  // owning
 
  private:
    void BuildModelStructure(SettingsModel& modelSettings);
 
    void CreateSubBasinComponents(SettingsModel& modelSettings);
 
    void CreateHydroUnitsComponents(SettingsModel& modelSettings);
 
    void CreateHydroUnitBrick(SettingsModel& modelSettings, HydroUnit* unit, int iBrick);
 
    void UpdateSubBasinParameters(SettingsModel& modelSettings);
 
    void UpdateHydroUnitsParameters(SettingsModel& modelSettings);
 
    void LinkSurfaceComponentsParents(SettingsModel& modelSettings, HydroUnit* unit);
 
    void LinkSubBasinProcessesTargetBricks(SettingsModel& modelSettings);
 
    void LinkHydroUnitProcessesTargetBricks(SettingsModel& modelSettings, HydroUnit* unit);
 
    void BuildForcingConnections(const BrickSettings& brickSettings, HydroUnit* unit, Brick* brick);
 
    void BuildForcingConnections(const ProcessSettings& processSettings, HydroUnit* unit, Process* process);
 
    void BuildForcingConnections(const SplitterSettings& splitterSettings, HydroUnit* unit, Splitter* splitter);
 
    void BuildSubBasinBricksFluxes(SettingsModel& modelSettings);
 
    void BuildHydroUnitBricksFluxes(SettingsModel& modelSettings, HydroUnit* unit);
 
    void BuildSubBasinSplittersFluxes(SettingsModel& modelSettings);
 
    void BuildHydroUnitSplittersFluxes(SettingsModel& modelSettings, HydroUnit* unit);
 
    void ConnectLoggerToValues(SettingsModel& modelSettings);
 
    bool InitializeTimeSeries();
 
    bool UpdateForcing();
};
 
#endif  // HYDROBRICKS_MODEL_HYDRO_H