Process.h

#ifndef HYDROBRICKS_PROCESS_H
#define HYDROBRICKS_PROCESS_H
 
#include <memory>
 
#include "Flux.h"
#include "Forcing.h"
#include "Includes.h"
#include "SettingsModel.h"
 
class Brick;
class HydroUnit;
class TimeMachine;
class WaterContainer;
 
class Process {
  public:
    explicit Process(WaterContainer* container);
 
    virtual ~Process() = default;
 
    static std::unique_ptr<Process> Factory(const ProcessSettings& processSettings, Brick* brick);
 
    [[nodiscard]] static bool RegisterSettings(SettingsModel* modelSettings, const string& processType);
 
    virtual void Reset();
 
    [[nodiscard]] virtual bool IsValid() const = 0;
 
    virtual void Validate() const;
 
    [[nodiscard]] static bool HasParameter(const ProcessSettings& processSettings, std::string_view name);
 
    static const float* GetParameterValuePointer(const ProcessSettings& processSettings, std::string_view name);
 
    virtual void SetHydroUnitProperties(HydroUnit* unit, Brick* brick);
 
    virtual void SetParameters(const ProcessSettings& processSettings);
 
    virtual void AttachForcing(Forcing*) {
        throw ShouldNotHappen("Process::AttachForcing - Should not be called (virtual)");
    }
 
    void AttachFluxOut(std::unique_ptr<Flux> flux) {
        assert(flux);
        _outputs.push_back(std::move(flux));
    }
 
    int GetOutputFluxCount() const {
        return static_cast<int>(_outputs.size());
    }
 
    Flux* GetOutputFlux(size_t index) const {
        assert(_outputs.size() > index);
        assert(_outputs[index]);
        return _outputs[index].get();
    }
 
    [[nodiscard]] virtual bool ToAtmosphere() const {
        return false;
    }
 
    [[nodiscard]] virtual bool NeedsTargetBrickLinking() const {
        return false;
    }
 
    [[nodiscard]] virtual int GetConnectionCount() const = 0;
 
    [[nodiscard]] virtual const vecDouble& GetChangeRates();
 
    virtual void StoreInOutgoingFlux(double* rate, int index);
 
    void ApplyChange(int connectionIndex, double rate, double timeStepInDays);
 
    virtual void Finalize() {
        // Nothing to do here.
    }
 
    virtual vecDoublePt GetStateVariables() {
        return vecDoublePt{};
    }
 
    [[nodiscard]] virtual double* GetValuePointer(std::string_view name);
 
    const string& GetName() const {
        return _name;
    }
 
    void SetName(const string& name) {
        _name = name;
    }
 
    void SetTimeMachine(TimeMachine* timeMachine) {
        _timeMachine = timeMachine;
    }
 
    WaterContainer* GetWaterContainer() const {
        return _container;
    }
 
    virtual void SetTargetBrick(Brick*) {
        throw ShouldNotHappen("Process::SetTargetBrick - Should not be called (virtual)");
    }
 
    [[nodiscard]] virtual bool LinksMultipleTargets() const {
        return false;
    }
 
    virtual void AddTargetBrickWithWeights(Brick*, const std::vector<Brick*>&) {
        throw ShouldNotHappen("Process::AddTargetBrickWithWeights - Should not be called (virtual)");
    }
 
    [[nodiscard]] virtual bool IsLateralProcess() const noexcept {
        return false;
    }
 
    [[nodiscard]] bool HasOutputFluxes() const noexcept {
        return !_outputs.empty();
    }
 
    [[nodiscard]] bool HasWaterContainer() const noexcept {
        return _container != nullptr;
    }
 
  protected:
    string _name;
    WaterContainer* _container;                   // non-owning reference
    TimeMachine* _timeMachine{nullptr};           // non-owning reference
    std::vector<std::unique_ptr<Flux>> _outputs;  // owning
    vecDouble _changeRates;                       // reusable buffer for the change rates (avoids per-call allocation)
 
    const vecDouble& StoreRates(std::initializer_list<double> rates) {
        _changeRates.assign(rates);
        return _changeRates;
    }
 
    [[nodiscard]] double GetSumChangeRatesOtherProcesses() const;
 
    [[nodiscard]] virtual const vecDouble& GetRates() = 0;
};
 
#endif  // HYDROBRICKS_PROCESS_H