WaterContainer.h

#ifndef HYDROBRICKS_WATER_CONTAINER_H
#define HYDROBRICKS_WATER_CONTAINER_H
 
#include "Includes.h"
#include "Process.h"
 
class Brick;
 
class WaterContainer : public wxObject {
  public:
    WaterContainer(Brick* brick);
 
    ~WaterContainer() override = default;
 
    virtual bool IsValid(bool checkProcesses = true) const;
 
    virtual void Validate() const;
 
    void SubtractAmountFromDynamicContentChange(double change);
 
    void AddAmountToDynamicContentChange(double change);
 
    void AddAmountToStaticContentChange(double change);
 
    virtual void ApplyConstraints(double timeStep);
 
    void SetOutgoingRatesToZero();
 
    void Finalize();
 
    void Reset();
 
    void SaveAsInitialState();
 
    vecDoublePt GetDynamicContentChanges();
 
    [[nodiscard]] bool HasMaximumCapacity() const {
        return _capacity != nullptr;
    }
 
    double GetMaximumCapacity() const {
        wxASSERT(_capacity);
        return *_capacity;
    }
 
    void SetMaximumCapacity(const float* value) {
        if (_infiniteStorage) {
            throw ModelConfigError(_("Trying to set the maximum capacity of an infinite storage."));
        }
        _capacity = value;
    }
 
    void SetAsInfiniteStorage() {
        _infiniteStorage = true;
    }
 
    double GetContentWithChanges() const {
        if (_infiniteStorage) {
            return INFINITY;
        }
 
        return _content + _contentChangeDynamic + _contentChangeStatic;
    }
 
    double GetContentWithDynamicChanges() const {
        if (_infiniteStorage) {
            return INFINITY;
        }
 
        return _content + _contentChangeDynamic;
    }
 
    double GetContentWithoutChanges() const {
        if (_infiniteStorage) {
            return INFINITY;
        }
 
        return _content;
    }
 
    double* GetContentPointer() {
        return &_content;
    }
 
    void SetInitialState(double value) {
        _initialState = value;
    }
 
    void UpdateContent(double value) {
        if (_infiniteStorage) {
            throw ModelConfigError(_("Trying to set the content of an infinite storage."));
        }
 
        _content = value;
    }
 
    double GetTargetFillingRatio() const;
 
    bool IsNotEmpty() const {
        double content = GetContentWithChanges();
        return GreaterThan(content, 0, EPSILON_F) && GreaterThan(content, 0, PRECISION);
    }
 
    bool HasOverflow() const {
        return _overflow != nullptr;
    }
 
    void LinkOverflow(Process* overflow) {
        _overflow = overflow;
    }
 
    void AttachFluxIn(Flux* flux) {
        wxASSERT(flux);
        _inputs.push_back(flux);
    }
 
    virtual double SumIncomingFluxes() const;
 
    virtual bool ContentAccessible() const;
 
    Brick* GetParentBrick() const {
        return _parent;
    }
 
    [[nodiscard]] bool HasIncomingFluxes() const {
        return !_inputs.empty();
    }
 
    [[nodiscard]] bool IsInfiniteStorage() const {
        return _infiniteStorage;
    }
 
    [[nodiscard]] bool IsEmpty() const {
        return !IsNotEmpty();
    }
 
    [[nodiscard]] bool HasParentBrick() const {
        return _parent != nullptr;
    }
 
    [[nodiscard]] bool HasInitialState() const {
        return !NearlyZero(_initialState, EPSILON_F);
    }
 
  private:
    double _content;               // [mm]
    double _contentChangeDynamic;  // [mm]
    double _contentChangeStatic;   // [mm]
    double _initialState;          // [mm]
    const float* _capacity;        // non-owning reference
    bool _infiniteStorage;
    Brick* _parent;         // non-owning reference
    Process* _overflow;     // non-owning reference
    vector<Flux*> _inputs;  // non-owning references to fluxes owned by processes
};
 
#endif  // HYDROBRICKS_WATER_CONTAINER_H