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);
 
    virtual bool IsOk();
 
    void SubtractAmountFromDynamicContentChange(double change);
 
    void AddAmountToDynamicContentChange(double change);
 
    void AddAmountToStaticContentChange(double change);
 
    virtual void ApplyConstraints(double timeSte);
 
    void SetOutgoingRatesToZero();
 
    void Finalize();
 
    void Reset();
 
    void SaveAsInitialState();
 
    vecDoublePt GetDynamicContentChanges();
 
    bool HasMaximumCapacity() const {
        return _capacity != nullptr;
    }
 
    double GetMaximumCapacity() {
        wxASSERT(_capacity);
        return *_capacity;
    }
 
    void SetMaximumCapacity(float* value) {
        if (_infiniteStorage) {
            throw ConceptionIssue(_("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 ConceptionIssue(_("Trying to set the content of an infinite storage."));
        }
 
        _content = value;
    }
 
    double GetTargetFillingRatio();
 
    bool IsNotEmpty() {
        double content = GetContentWithChanges();
        return content > EPSILON_F && content > PRECISION;
    }
 
    bool HasOverflow() {
        return _overflow != nullptr;
    }
 
    void LinkOverflow(Process* overflow) {
        _overflow = overflow;
    }
 
    void AttachFluxIn(Flux* flux) {
        wxASSERT(flux);
        _inputs.push_back(flux);
    }
 
    virtual double SumIncomingFluxes();
 
    virtual bool ContentAccessible() const;
 
    Brick* GetParentBrick() {
        return _parent;
    }
 
  private:
    double _content;               // [mm]
    double _contentChangeDynamic;  // [mm]
    double _contentChangeStatic;   // [mm]
    double _initialState;          // [mm]
    float* _capacity;
    bool _infiniteStorage;
    Brick* _parent;
    Process* _overflow;
    vector<Flux*> _inputs;
};
 
#endif  // HYDROBRICKS_WATER_CONTAINER_H