HydroUnit.h

#ifndef HYDROBRICKS_HYDRO_UNIT_H
#define HYDROBRICKS_HYDRO_UNIT_H
 
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "Brick.h"
#include "Forcing.h"
#include "HydroUnitLateralConnection.h"
#include "HydroUnitProperty.h"
#include "Includes.h"
#include "LandCover.h"
#include "Splitter.h"
 
struct HydroUnitSettings;
 
class HydroUnit : public wxObject {
  public:
    enum Types {
        Distributed,
        SemiDistributed,
        Lumped,
        Undefined
    };
 
    explicit HydroUnit(double area = UNDEFINED, Types type = Undefined);
 
    ~HydroUnit() override;
 
    void Reset();
 
    void SaveAsInitialState();
 
    void SetProperties(HydroUnitSettings& unitSettings);
 
    void AddProperty(std::unique_ptr<HydroUnitProperty> property);
 
    double GetPropertyDouble(const string& name, const string& unit = "") const;
 
    float GetPropertyFloat(const string& name, const string& unit = "") const;
 
    string GetPropertyString(const string& name) const;
 
    void AddBrick(std::unique_ptr<Brick> brick);
 
    void AddSplitter(std::unique_ptr<Splitter> splitter);
 
    [[nodiscard]] bool HasForcing(VariableType type);
 
    void AddForcing(std::unique_ptr<Forcing> forcing);
 
    Forcing* GetForcing(VariableType type) const;
 
    void AddLateralConnection(HydroUnit* receiver, double fraction, const string& type = "");
 
    void ReserveBricks(size_t count);
 
    void ReserveLandCoverBricks(size_t count);
 
    void ReserveSplitters(size_t count);
 
    void ReserveLateralConnections(size_t count);
 
    void ReserveForcings(size_t count);
 
    int GetBrickCount() const;
 
    int GetSplitterCount() const;
 
    Brick* GetBrick(size_t index) const;
 
    [[nodiscard]] bool HasBrick(const string& name) const;
 
    Brick* GetBrick(const string& name) const;
 
    Brick* TryGetBrick(const string& name) const;
 
    [[nodiscard]] std::vector<Brick*> GetSnowpacks() const {
        std::vector<Brick*> snowBricks;
        snowBricks.reserve(_bricks.size());
        for (const auto& brick : _bricks) {
            if (brick->GetCategory() == BrickCategory::Snowpack) {
                snowBricks.push_back(brick.get());
            }
        }
        return snowBricks;
    }
 
    LandCover* GetLandCover(const string& name) const;
 
    LandCover* TryGetLandCover(const string& name) const;
 
    Splitter* GetSplitter(size_t index) const;
 
    [[nodiscard]] bool HasSplitter(const string& name) const;
 
    Splitter* GetSplitter(const string& name) const;
 
    Splitter* TryGetSplitter(const string& name) const;
 
    [[nodiscard]] bool IsValid(bool checkProcesses = true) const;
 
    void Validate() const;
 
    bool ChangeLandCoverAreaFraction(const string& name, double fraction);
 
    bool FixLandCoverFractionsTotal();
 
    Types GetType() const {
        return _type;
    }
 
    void SetId(int id) {
        _id = id;
    }
 
    [[nodiscard]] double GetArea() const {
        return _area;
    }
 
    [[nodiscard]] int GetId() const {
        return _id;
    }
 
    [[nodiscard]] std::vector<HydroUnitLateralConnection*> GetLateralConnections() const;
 
  protected:
    Types _type;
    int _id;
    double _area;                                                                  // [m²]
    std::vector<std::unique_ptr<HydroUnitProperty>> _properties;                   // owning
    std::vector<std::unique_ptr<HydroUnitLateralConnection>> _lateralConnections;  // owning
    std::vector<std::unique_ptr<Brick>> _bricks;                                   // owning
    std::unordered_map<string, Brick*> _brickMap;                                  // non-owning view into _bricks
    std::vector<LandCover*> _landCoverBricks;                                      // non-owning view into _bricks
    std::unordered_map<string, LandCover*> _landCoverMap;    // non-owning view into _landCoverBricks
    std::vector<std::unique_ptr<Splitter>> _splitters;       // owning
    std::unordered_map<string, Splitter*> _splitterMap;      // non-owning view into _splitters
    std::vector<std::unique_ptr<Forcing>> _forcing;          // owning
    std::unordered_map<VariableType, Forcing*> _forcingMap;  // non-owning view into _forcing
};
 
#endif