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:
    enum Types {
        Distributed,
        SemiDistributed,
        Lumped,
        Undefined
    };
 
    explicit HydroUnit(double area = UNDEFINED, Types type = Undefined);
 
    virtual ~HydroUnit();
 
    void Reset();
 
    void SaveAsInitialState();
 
    void SetProperties(HydroUnitSettings& unitSettings);
 
    void AddProperty(std::unique_ptr<HydroUnitProperty> property);
 
    [[nodiscard]] double GetPropertyDouble(std::string_view name, std::string_view unit = "") const;
 
    [[nodiscard]] float GetPropertyFloat(std::string_view name, std::string_view unit = "") const;
 
    [[nodiscard]] string GetPropertyString(std::string_view name) const;
 
    [[nodiscard]] bool HasProperty(std::string_view name) const;
 
    void SetParameterOverride(const string& key, float value);
 
    [[nodiscard]] bool HasParameterOverride(const string& key) const;
 
    [[nodiscard]] const float* GetParameterOverridePointer(const string& key) const;
 
    void SetParameterOverrideMonthly(const string& key, const vecFloat& values);
 
    [[nodiscard]] vector<std::pair<float*, const vecFloat*>> GetMonthlyParameterOverrides();
 
    void AddBrick(std::unique_ptr<Brick> brick);
 
    void AddSplitter(std::unique_ptr<Splitter> splitter);
 
    [[nodiscard]] bool HasForcing(VariableType type) const;
 
    void AddForcing(std::unique_ptr<Forcing> forcing);
 
    [[nodiscard]] Forcing* GetForcing(VariableType type) const;
 
    void ResetForcingUpdates();
 
    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);
 
    [[nodiscard]] int GetBrickCount() const;
 
    [[nodiscard]] int GetSplitterCount() const;
 
    [[nodiscard]] Brick* GetBrick(size_t index) const;
 
    [[nodiscard]] bool HasBrick(std::string_view name) const;
 
    [[nodiscard]] Brick* GetBrick(std::string_view name) const;
 
    [[nodiscard]] Brick* TryGetBrick(std::string_view 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;
    }
 
    [[nodiscard]] double GetSnowCoverFraction(double sweThreshold = 0.1) const;
 
    [[nodiscard]] double GetSnowAlbedo(double albedoLand, const LandCover* cover = nullptr,
                                       double sweThreshold = 0.1) const;
 
    [[nodiscard]] LandCover* GetLandCover(std::string_view name) const;
 
    [[nodiscard]] LandCover* TryGetLandCover(std::string_view name) const;
 
    [[nodiscard]] Splitter* GetSplitter(size_t index) const;
 
    [[nodiscard]] bool HasSplitter(std::string_view name) const;
 
    [[nodiscard]] Splitter* GetSplitter(std::string_view name) const;
 
    [[nodiscard]] Splitter* TryGetSplitter(std::string_view name) const;
 
    [[nodiscard]] bool IsValid(bool checkProcesses = true) const;
 
    void Validate() const;
 
    bool ChangeLandCoverAreaFraction(std::string_view name, double fraction);
 
    bool FixLandCoverFractionsTotal();
 
    void RestoreInitialAreaFractions();
 
    [[nodiscard]] LandCover* GetGenericLandCover() const;
 
    Types GetType() const {
        return _type;
    }
 
    void SetId(int id) {
        _id = id;
    }
 
    [[nodiscard]] double GetArea() const {
        return _area;
    }
 
    [[nodiscard]] int GetId() const {
        return _id;
    }
 
    void SetStructureId(int structureId) {
        _structureId = structureId;
    }
 
    [[nodiscard]] int GetStructureId() const {
        return _structureId;
    }
 
    [[nodiscard]] std::vector<HydroUnitLateralConnection*> GetLateralConnections() const;
 
  private:
    void TransferLandCoverContent(LandCover* changed, double oldFraction, double newFraction, LandCover* generic,
                                  double genericOldFraction, double genericNewFraction);
 
  protected:
    Types _type;
    int _id;
    int _structureId = 1;                                                          // model-structure variant used
    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
    std::unordered_map<string, float> _paramOverrides;            // per-unit spatial parameter values
    std::unordered_map<string, vecFloat> _paramOverridesMonthly;  // per-unit monthly values (Jan..Dec)
};
 
#endif