WaterContainer.h

#ifndef HYDROBRICKS_WATER_CONTAINER_H
#define HYDROBRICKS_WATER_CONTAINER_H
 
#include "Includes.h"
#include "Process.h"
 
class Brick;
class FluxToBrickInstantaneous;
 
class WaterContainer {
  public:
    WaterContainer(Brick* brick);
 
    virtual ~WaterContainer() = default;
 
    [[nodiscard]] 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();
 
    double BookIncomingFluxes(bool asStatic = false);
 
    void ResetInputBooking() {
        _inputsBooked = false;
    }
 
    void Finalize();
 
    void Reset();
 
    void SaveAsInitialState();
 
    [[nodiscard]] vecDoublePt GetDynamicContentChanges();
 
    [[nodiscard]] bool HasMaximumCapacity() const noexcept {
        return _capacity != nullptr;
    }
 
    [[nodiscard]] double GetMaximumCapacity() const {
        assert(_capacity);
        if (_areaFraction != nullptr) {
            return *_capacity * *_areaFraction;
        }
        return *_capacity;
    }
 
    [[nodiscard]] double GetAreaFraction() const {
        return _areaFraction != nullptr ? *_areaFraction : 1.0;
    }
 
    void SetAreaFraction(const double* areaFraction) {
        _areaFraction = areaFraction;
    }
 
    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;
    }
 
    void SetAllowNegativeContent(bool allow = true) {
        _allowNegativeContent = allow;
    }
 
    [[nodiscard]] bool AllowsNegativeContent() const {
        return _allowNegativeContent;
    }
 
    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;
    }
 
    [[nodiscard]] 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) {
        assert(flux);
        _inputs.push_back(flux);
    }
 
    void AttachFluxInOwned(std::unique_ptr<Flux> flux) {
        assert(flux);
        _inputs.push_back(flux.get());
        _ownedInputFluxes.push_back(std::move(flux));
    }
 
    virtual double SumIncomingFluxes() const;
 
    double SumIncomingChangeRates() const;
 
    double SumIncomingAmounts() 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:
    void BuildConstraintCache();
 
    struct OutgoingLink {
        Flux* flux;
        Process* process;  // non-owning; kept for error reporting
        bool priority;
    };
 
    bool _constraintCacheBuilt;                                     // the flux classification below is filled in
    std::vector<OutgoingLink> _outgoingFluxes;                      // outgoing fluxes of this container's processes
    std::vector<Flux*> _incomingRateFluxes;                         // incoming fluxes carrying a change rate
    std::vector<Flux*> _incomingAmountFluxes;                       // incoming forcing / static fluxes (amounts)
    std::vector<FluxToBrickInstantaneous*> _incomingInstantFluxes;  // incoming instantaneous fluxes
 
    double _content;               // [mm]
    double _contentChangeDynamic;  // [mm]
    double _contentChangeStatic;   // [mm]
    double _initialState;          // [mm]
    const float* _capacity;        // non-owning reference
    const double* _areaFraction;   // area fraction of the land cover represented (non-owning)
    bool _infiniteStorage;
    bool _allowNegativeContent;
    bool _inputsBooked;                                    // incoming amounts already in the content changes
    Brick* _parent;                                        // non-owning reference
    Process* _overflow;                                    // non-owning reference
    vector<Flux*> _inputs;                                 // non-owning references
    std::vector<std::unique_ptr<Flux>> _ownedInputFluxes;  // owning: forcing fluxes not owned by processes
};
 
#endif  // HYDROBRICKS_WATER_CONTAINER_H