Brick.h

#ifndef HYDROBRICKS_BRICK_H
#define HYDROBRICKS_BRICK_H
 
#include <memory>
 
#include "Flux.h"
#include "Includes.h"
#include "Process.h"
#include "SettingsModel.h"
#include "WaterContainer.h"
 
enum class BrickCategory {
    Snowpack,          
    Glacier,           
    Urban,             
    Vegetation,        
    GenericLandCover,  
    Unknown            
};
 
class Brick {
  public:
    explicit Brick();
 
    virtual ~Brick() = default;
 
    static std::unique_ptr<Brick> Factory(const BrickSettings& brickSettings);
 
    static std::unique_ptr<Brick> Factory(BrickType type);
 
    static bool HasParameter(const BrickSettings& brickSettings, std::string_view name);
 
    static const float* GetParameterValuePointer(const BrickSettings& brickSettings, std::string_view name);
 
    virtual void SetParameters(const BrickSettings& brickSettings);
 
    virtual void AttachFluxIn(Flux* flux);
 
    virtual void AttachFluxIn(std::unique_ptr<Flux> flux);
 
    void AddProcess(std::unique_ptr<Process> process) {
        assert(process);
        _processes.push_back(std::move(process));
    }
 
    virtual void Reset();
 
    virtual void SaveAsInitialState();
 
    [[nodiscard]] virtual bool IsValid(bool checkProcesses = true) const;
 
    virtual void Validate() const;
 
    [[nodiscard]] bool NeedsSolver() const {
        return _needsSolver;
    }
 
    void SetNeedsSolver(bool needsSolver) {
        _needsSolver = needsSolver;
    }
 
    [[nodiscard]] BrickCategory GetCategory() const {
        return _category;
    }
 
    [[nodiscard]] virtual bool CanHaveAreaFraction() const {
        return false;
    }
 
    [[nodiscard]] virtual bool IsLandCover() const {
        return false;
    }
 
    [[nodiscard]] virtual bool IsNull() const {
        return false;
    }
 
    [[nodiscard]] bool HasProcesses() const {
        return !_processes.empty();
    }
 
    [[nodiscard]] bool HasHydroUnit() const {
        return _hydroUnit != nullptr;
    }
 
    virtual void Finalize();
 
    virtual void SetInitialState(double value, ContentType type);
 
    [[nodiscard]] virtual double GetContent(ContentType type) const;
 
    virtual void UpdateContent(double value, ContentType type);
 
    virtual void UpdateContentFromInputs();
 
    virtual void ApplyConstraints(double timeStep);
 
    [[nodiscard]] WaterContainer* GetWaterContainer() const;
 
    [[nodiscard]] size_t GetProcessCount() const noexcept {
        return _processes.size();
    }
 
    [[nodiscard]] Process* GetProcess(size_t index) const;
 
    [[nodiscard]] const string& GetName() const noexcept {
        return _name;
    }
 
    void SetName(std::string_view name) {
        _name = string(name);
    }
 
    HydroUnit* GetHydroUnit() const {
        assert(_hydroUnit);
        return _hydroUnit;
    }
 
    void SetHydroUnit(HydroUnit* hydroUnit) {
        assert(hydroUnit);
        _hydroUnit = hydroUnit;
    }
 
    virtual vecDoublePt GetDynamicContentChanges();
 
    vecDoublePt GetStateVariableChangesFromProcesses();
 
    int GetProcessConnectionCount() const;
 
    double* GetBaseValuePointer(std::string_view name);
 
    virtual double* GetValuePointer(std::string_view name);
 
  protected:
    string _name;
    bool _needsSolver;
    BrickCategory _category;
    std::unique_ptr<WaterContainer> _water;            // owning
    std::vector<std::unique_ptr<Process>> _processes;  // owning
    HydroUnit* _hydroUnit;                             // non-owning back-reference
};
 
#endif  // HYDROBRICKS_BRICK_H