Process.h

#ifndef HYDROBRICKS_PROCESS_H
#define HYDROBRICKS_PROCESS_H
 
#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);
 
    static bool RegisterParametersAndForcing(SettingsModel* modelSettings, const string& processType);
 
    void Reset();
 
    virtual bool IsOk() = 0;
 
    static bool HasParameter(const ProcessSettings& processSettings, const string& name);
 
    static 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();
    }
 
    void AttachFluxOut(Flux* flux) {
        wxASSERT(flux);
        m_outputs.push_back(flux);
    }
 
    vector<Flux*> GetOutputFluxes() {
        return m_outputs;
    }
 
    int GetOutputFluxesNb() {
        return static_cast<int>(m_outputs.size());
    }
 
    virtual bool ToAtmosphere() {
        return false;
    }
 
    virtual bool NeedsTargetBrickLinking() {
        return false;
    }
 
    virtual int GetConnectionsNb() = 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);
 
    string GetName() {
        return m_name;
    }
 
    void SetName(const string& name) {
        m_name = name;
    }
 
    WaterContainer* GetWaterContainer() {
        return m_container;
    }
 
    virtual void SetTargetBrick(Brick*) {
        throw ShouldNotHappen();
    }
 
  protected:
    string m_name;
    WaterContainer* m_container;
    vector<Flux*> m_outputs;
 
    double GetSumChangeRatesOtherProcesses();
 
    virtual vecDouble GetRates() = 0;
};
 
#endif  // HYDROBRICKS_PROCESS_H