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 WaterContainer;
 
class Process : public wxObject {
  public:
    explicit Process(WaterContainer* container);
 
    ~Process() override = default;
 
    static Process* Factory(const ProcessSettings& processSettings, Brick* brick);
 
    [[nodiscard]] static bool RegisterParametersAndForcing(SettingsModel* modelSettings, const string& processType);
 
    void Reset();
 
    [[nodiscard]] virtual bool IsValid() const = 0;
 
    virtual void Validate() const;
 
    [[nodiscard]] static bool HasParameter(const ProcessSettings& processSettings, const string& name);
 
    static const float* GetParameterValuePointer(const ProcessSettings& processSettings, const string& 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) {
        wxASSERT(flux);
        _outputs.push_back(std::move(flux));
    }
 
    int GetOutputFluxCount() const {
        return static_cast<int>(_outputs.size());
    }
 
    Flux* GetOutputFlux(size_t index) const {
        wxASSERT(_outputs.size() > index);
        wxASSERT(_outputs[index]);
        return _outputs[index].get();
    }
 
    [[nodiscard]] virtual bool ToAtmosphere() const {
        return false;
    }
 
    [[nodiscard]] virtual bool NeedsTargetBrickLinking() const {
        return false;
    }
 
    virtual int GetConnectionCount() const = 0;
 
    virtual 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{};
    }
 
    virtual double* GetValuePointer(const string& name);
 
    const string& GetName() const {
        return _name;
    }
 
    void SetName(const string& name) {
        _name = name;
    }
 
    WaterContainer* GetWaterContainer() const {
        return _container;
    }
 
    virtual void SetTargetBrick(Brick*) {
        throw ShouldNotHappen("Process::SetTargetBrick - Should not be called (virtual)");
    }
 
    [[nodiscard]] virtual bool IsLateralProcess() const {
        return false;
    }
 
    [[nodiscard]] bool HasOutputFluxes() const {
        return !_outputs.empty();
    }
 
    [[nodiscard]] bool HasWaterContainer() const {
        return _container != nullptr;
    }
 
  protected:
    string _name;
    WaterContainer* _container;                   // non-owning reference
    std::vector<std::unique_ptr<Flux>> _outputs;  // owning
 
    double GetSumChangeRatesOtherProcesses() const;
 
    virtual vecDouble GetRates() = 0;
};
 
#endif  // HYDROBRICKS_PROCESS_H