SettingsModel.h

#ifndef HYDROBRICKS_SETTINGS_MODEL_H
#define HYDROBRICKS_SETTINGS_MODEL_H
 
#include <yaml-cpp/yaml.h>
 
#include <memory>
 
#include "Includes.h"
#include "Parameter.h"
 
struct SolverSettings {
    string name;
};
 
struct TimerSettings {
    string start;
    string end;
    int timeStep = 1;
    string timeStepUnit;
    int spinupDays = 0;
};
 
struct OutputSettings {
    string target;
    ContentType fluxType = ContentType::Water;
    bool isInstantaneous = false;
    bool isStatic = false;
};
 
struct ProcessSettings {
    string name;
    string type;
    vecStr logItems;
    vector<Parameter> parameters;
    vector<VariableType> forcing;
    vector<OutputSettings> outputs;
};
 
struct SplitterSettings {
    string name;
    string type;
    vecStr logItems;
    vector<Parameter> parameters;
    vector<VariableType> forcing;
    vector<OutputSettings> outputs;
};
 
struct BrickSettings {
    string name;
    string type;
    string parent;
    vecStr logItems;
    vector<Parameter> parameters;
    vector<VariableType> forcing;
    vector<ProcessSettings> processes;
    bool computedDirectly = false;  // if true, the brick is solved explicitly (no ODE solver)
};
 
struct ModelStructure {
    int id;
    vecStr logItems;
    vector<BrickSettings> hydroUnitBricks;
    vector<BrickSettings> subBasinBricks;
    vecInt landCoverBricks;
    vecInt surfaceComponentBricks;
    vector<SplitterSettings> hydroUnitSplitters;
    vector<SplitterSettings> subBasinSplitters;
};
 
class SettingsModel {
  public:
    explicit SettingsModel();
 
    virtual ~SettingsModel();
 
    void SetSolver(const string& solverName);
 
    void SetTimer(const string& start, const string& end, int timeStep, const string& timeStepUnit);
 
    void SetSpinupDays(int days);
 
    void AddHydroUnitBrick(const string& name, const std::string& type = "storage");
 
    void AddSubBasinBrick(const string& name, const std::string& type = "storage");
 
    void AddLandCoverBrick(const string& name, const string& type);
 
    void AddSurfaceComponentBrick(const string& name, const string& type);
 
    void SetSurfaceComponentParent(const string& name);
 
    void AddBrickParameter(const string& name, float value, const std::string& type = "constant");
 
    void SetBrickParameterValue(const string& name, float value, const std::string& type = "constant");
 
    void SetCurrentBrickComputedDirectly();
 
    bool BrickHasParameter(const string& name);
 
    void AddBrickForcing(const string& name);
 
    void AddBrickProcess(const string& name, const string& type, const string& target = "", bool log = false);
 
    void AddProcessParameter(const string& name, float value, const std::string& type = "constant");
 
    void SetProcessParameterValue(const string& name, float value, const std::string& type = "constant");
 
    void AddProcessForcing(const string& name);
 
    void AddProcessOutput(const string& target, ContentType fluxType = ContentType::Water);
 
    void SetProcessOutputsAsInstantaneous();
 
    void SetProcessOutputsAsStatic();
 
    void OutputProcessToSameBrick();
 
    void AddHydroUnitSplitter(const string& name, const string& type);
 
    void AddSubBasinSplitter(const string& name, const string& type);
 
    void AddSplitterParameter(const string& name, float value, const std::string& type = "constant");
 
    void SetSplitterParameterValue(const string& name, float value, const std::string& type = "constant");
 
    void AddSplitterForcing(const string& name);
 
    void AddSplitterOutput(const string& target, const ContentType fluxType = ContentType::Water);
 
    void ChangeSplitterOutputTarget(const string& currentTarget, const string& newTarget);
 
    bool ChangeSplitterOutputTargetIfFound(const string& currentTarget, const string& newTarget);
 
    void GenerateCanopyInterception(const string& coverName, const string& throughfallTarget);
 
    void AddLoggingToItem(const string& itemName);
 
    void AddLoggingToItems(std::initializer_list<const string> items);
 
    void AddBrickLogging(const string& itemName);
 
    void AddBrickLogging(std::initializer_list<const string> items);
 
    void AddProcessLogging(const string& itemName);
 
    void AddSplitterLogging(const string& itemName);
 
    void GeneratePrecipitationSplitters(bool withSnow, const string& splitterType = "snow_rain:linear");
 
    void GenerateSnowpacks(const string& snowMeltProcess);
 
    void AddSnowIceTransformation(const string& transformationProcess = "transform:snow_ice_swat");
 
    void AddSnowRedistribution(const string& redistributionProcess = "transport:snow_slide", bool skipGlaciers = false);
 
    void GenerateSnowpacksWithWaterRetention(const string& snowMeltProcess, const string& outflowProcess,
                                             bool rainToSnowpack = false);
 
    void AddSnowpackRefreezing(const string& refreezingProcess = "refreeze:degree_day");
 
    void AddSnowpackSublimation(const string& sublimationProcess);
 
    int AddStructure();
 
    bool SelectStructure(int id);
 
    void SelectHydroUnitBrick(int index);
 
    void SelectSubBasinBrick(int index);
 
    bool SelectHydroUnitBrickIfFound(const string& name);
 
    bool SelectSubBasinBrickIfFound(const string& name);
 
    void SelectHydroUnitBrick(const string& name);
 
    void SelectHydroUnitBrickByName(const string& name);
 
    void SelectSubBasinBrick(const string& name);
 
    void SelectProcess(int index);
 
    void SelectProcess(const string& name);
 
    void SelectProcessWithParameter(const string& name);
 
    void SelectHydroUnitSplitter(int index);
 
    void SelectSubBasinSplitter(int index);
 
    bool SelectHydroUnitSplitterIfFound(const string& name);
 
    bool SelectSubBasinSplitterIfFound(const string& name);
 
    void SelectHydroUnitSplitter(const string& name);
 
    void SelectSubBasinSplitter(const string& name);
 
    bool SetParameterValue(const string& component, const string& name, float value);
 
    int GetStructureCount() const {
        return static_cast<int>(_modelStructures.size());
    }
 
    int GetHydroUnitBrickCount() const {
        assert(_selectedStructure);
        return static_cast<int>(_selectedStructure->hydroUnitBricks.size());
    }
 
    int GetSubBasinBrickCount() const {
        assert(_selectedStructure);
        return static_cast<int>(_selectedStructure->subBasinBricks.size());
    }
 
    int GetSurfaceComponentBrickCount() const {
        assert(_selectedStructure);
        return static_cast<int>(_selectedStructure->surfaceComponentBricks.size());
    }
 
    int GetProcessCount() const {
        assert(_selectedBrick);
        return static_cast<int>(_selectedBrick->processes.size());
    }
 
    int GetHydroUnitSplitterCount() const {
        assert(_selectedStructure);
        return static_cast<int>(_selectedStructure->hydroUnitSplitters.size());
    }
 
    int GetSubBasinSplitterCount() const {
        assert(_selectedStructure);
        return static_cast<int>(_selectedStructure->subBasinSplitters.size());
    }
 
    SolverSettings GetSolverSettings() const {
        return _solver;
    }
 
    TimerSettings GetTimerSettings() const {
        return _timer;
    }
 
    const BrickSettings& GetHydroUnitBrickSettings(int index) const {
        assert(_selectedStructure);
        return _selectedStructure->hydroUnitBricks[index];
    }
 
    const BrickSettings& GetHydroUnitBrickSettings(const string& name) const {
        assert(_selectedStructure);
 
        for (const auto& brick : _selectedStructure->hydroUnitBricks) {
            if (brick.name == name) {
                return brick;
            }
        }
 
        throw std::runtime_error("Brick not found.");
    }
 
    const BrickSettings& GetSurfaceComponentBrickSettings(int index) const {
        assert(_selectedStructure);
        int brickIndex = _selectedStructure->surfaceComponentBricks[index];
        return _selectedStructure->hydroUnitBricks[brickIndex];
    }
 
    vecInt GetSurfaceComponentBricksIndices() const {
        assert(_selectedStructure);
        return _selectedStructure->surfaceComponentBricks;
    }
 
    const vecInt& GetLandCoverBricksIndices() const {
        assert(_selectedStructure);
        return _selectedStructure->landCoverBricks;
    }
 
    vecStr GetLandCoverBricksNames() const;
 
    vecStr GetSelectedStructureLandCoverNames() const;
 
    const BrickSettings& GetSubBasinBrickSettings(int index) const {
        assert(_selectedStructure);
        return _selectedStructure->subBasinBricks[index];
    }
 
    const ProcessSettings& GetProcessSettings(int index) const {
        assert(_selectedBrick);
        return _selectedBrick->processes[index];
    }
 
    const SplitterSettings& GetHydroUnitSplitterSettings(int index) const {
        assert(_selectedStructure);
        return _selectedStructure->hydroUnitSplitters[index];
    }
 
    const SplitterSettings& GetSubBasinSplitterSettings(int index) const {
        assert(_selectedStructure);
        return _selectedStructure->subBasinSplitters[index];
    }
 
    vecStr GetSubBasinLogLabels() const;
 
    vecStr GetSubBasinGenericLogLabels() const;
 
    vecStr GetHydroUnitLogLabels() const;
 
    void SetLogAll(bool logAll = true) {
        if (logAll) {
            LogDebug("Logging all components.");
            _recordFractions = true;
        } else {
            LogDebug("Minimal logging.");
        }
        _logAll = logAll;
    }
 
    bool LogAll() const {
        return _logAll;
    }
 
    void SetRecordFractions(bool record = true) {
        _recordFractions = record;
    }
 
    bool RecordsFractions() const {
        return _recordFractions;
    }
 
    [[nodiscard]] bool IsValid() const;
 
    void Validate() const;
 
  protected:
    bool SetParameterValueInSelectedStructure(const string& component, const string& name, float value);
 
    bool _logAll;
    bool _recordFractions;
    vector<ModelStructure> _modelStructures;
    SolverSettings _solver;
    TimerSettings _timer;
    ModelStructure* _selectedStructure;   // non-owning reference
    BrickSettings* _selectedBrick;        // non-owning reference
    ProcessSettings* _selectedProcess;    // non-owning reference
    SplitterSettings* _selectedSplitter;  // non-owning reference
 
    bool LogAll(const YAML::Node& settings);
};
 
#endif  // HYDROBRICKS_SETTINGS_MODEL_H