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);
        _outputs.push_back(flux);
    }
 
    vector<Flux*> GetOutputFluxes() {
        return _outputs;
    }
 
    int GetOutputFluxesNb() {
        return static_cast<int>(_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 _name;
    }
 
    void SetName(const string& name) {
        _name = name;
    }
 
    WaterContainer* GetWaterContainer() {
        return _container;
    }
 
    virtual void SetTargetBrick(Brick*) {
        throw ShouldNotHappen();
    }
 
    virtual bool IsLateralProcess() const {
        return false;
    }
 
  protected:
    string _name;
    WaterContainer* _container;
    vector<Flux*> _outputs;
 
    double GetSumChangeRatesOtherProcesses();
 
    virtual vecDouble GetRates() = 0;
};
 
#endif  // HYDROBRICKS_PROCESS_H