Logger.h

#ifndef HYDROBRICKS_LOGGER_H
#define HYDROBRICKS_LOGGER_H
 
#include "Includes.h"
#include "SettingsModel.h"
#include "Subbasin.h"
 
class Logger {
  public:
    explicit Logger();
 
    virtual ~Logger() = default;
 
    void InitContainers(int timeSize, const std::vector<Subbasin*>& subbasins, SettingsModel& modelSettings);
 
    void Reset();
 
    void SetSubbasinValuePointer(int iSubbasin, int iLabel, double* valPt);
 
    void SetHydroUnitValuePointer(int iUnit, int iLabel, double* valPt);
 
    void SetHydroUnitFractionPointer(int iUnit, int iLabel, double* valPt);
 
    void SetHydroUnitLabelBasis(int iLabel, const string& basis);
 
    void SetDate(double date);
 
    void SaveInitialValues();
 
    void Record();
 
    void Increment();
 
    bool DumpOutputs(const string& path);
 
    [[nodiscard]] axd GetOutletDischarge() const;
 
    [[nodiscard]] axd GetSubbasinDischarge(int subbasinId) const;
 
    [[nodiscard]] vecInt GetIndicesForSubbasinElements(const string& item) const;
 
    [[nodiscard]] vecInt GetIndicesForHydroUnitElements(const string& item) const;
 
    [[nodiscard]] double GetTotalSubbasin(const string& item) const;
 
    [[nodiscard]] double GetTotalHydroUnits(const string& item, bool needsAreaWeighting = false) const;
 
    [[nodiscard]] double GetTotalOutletDischarge() const;
 
    [[nodiscard]] double GetTotalET() const;
 
    [[nodiscard]] double GetSubbasinInitialStorageState(const string& tag) const;
 
    [[nodiscard]] double GetSubbasinFinalStorageState(const string& tag) const;
 
    [[nodiscard]] int GetFractionIndexForComponent(const string& componentName) const;
 
    [[nodiscard]] double GetHydroUnitsInitialStorageState(const string& tag) const;
 
    [[nodiscard]] double GetHydroUnitsFinalStorageState(const string& tag) const;
 
    [[nodiscard]] double GetTotalWaterStorageChanges() const;
 
    [[nodiscard]] double GetTotalSnowStorageChanges() const;
 
    [[nodiscard]] double GetTotalGlacierStorageChanges() const;
 
    [[nodiscard]] vecAxd GetSubbasinValues() const;
 
    const vecAxxd& GetSubbasinValuesPerSubbasin() const {
        return _subbasinValues;
    }
 
    const vecAxxd& GetHydroUnitValues() const {
        return _hydroUnitValues;
    }
 
    const axd& GetTime() const {
        return _time;
    }
 
    const vecInt& GetSubbasinIds() const {
        return _subbasinIds;
    }
 
    const vecInt& GetSubbasinDownstreamIds() const {
        return _subbasinDownstreamIds;
    }
 
    const vecInt& GetSubbasinStructureIds() const {
        return _subbasinStructureIds;
    }
 
    const axd& GetSubbasinLocalAreas() const {
        return _subbasinLocalAreas;
    }
 
    const axd& GetSubbasinDrainedAreas() const {
        return _subbasinDrainedAreas;
    }
 
    [[nodiscard]] int GetSubbasinCount() const {
        return static_cast<int>(_subbasinIds.size());
    }
 
    const vecInt& GetHydroUnitIds() const {
        return _hydroUnitIds;
    }
 
    const axd& GetHydroUnitAreas() const {
        return _hydroUnitAreas;
    }
 
    const vecStr& GetSubbasinLabels() const {
        return _subbasinLabels;
    }
 
    const vecStr& GetHydroUnitLabels() const {
        return _hydroUnitLabels;
    }
 
    const vecStr& GetHydroUnitFractionLabels() const {
        return _hydroUnitFractionLabels;
    }
 
    const vecAxxd& GetHydroUnitFractions() const {
        return _hydroUnitFractions;
    }
 
    const vecStr& GetHydroUnitLabelBases() const {
        return _hydroUnitLabelBases;
    }
 
    const axd& GetHydroUnitSubbasinFractions() const {
        return _hydroUnitSubbasinFractions;
    }
 
    void RecordFractions() {
        _recordFractions = true;
    }
 
    void AddSubbasinEtIndex(int iLabel);
 
    void AddHydroUnitEtIndex(int iLabel) {
        _hydroUnitEtIndices.push_back(iLabel);
    }
 
  protected:
    int _cursor;
    axd _time;
    bool _recordFractions;
    vecInt _subbasinIds;  // processing order, the outlet last
    vecInt _subbasinDownstreamIds;
    vecInt _subbasinStructureIds;
    axd _subbasinLocalAreas;
    axd _subbasinDrainedAreas;
    axd _subbasinWeights;  // local area / catchment area, to sum subbasin values over the catchment
    int _outletIndex;      // index of the terminal subbasin
    vecStr _subbasinLabels;
    vecAxd _subbasinInitialValues;          // [label](subbasins)
    vecAxxd _subbasinValues;                // [label](time x subbasins)
    vector<vecDoublePt> _subbasinValuesPt;  // [label][subbasin]
    vecInt _hydroUnitIds;
    vecInt _hydroUnitStructureIds;
    axd _hydroUnitAreas;
    vecStr _hydroUnitLabels;
    vecStr _hydroUnitLabelBases;      // [label] area the values are expressed over
    axd _hydroUnitSubbasinFractions;  // [unit] unit area / subbasin area
    vecAxd _hydroUnitInitialValues;
    vecAxxd _hydroUnitValues;
    vector<vecDoublePt> _hydroUnitValuesPt;
    vecStr _hydroUnitFractionLabels;
    vecAxxd _hydroUnitFractions;
    vector<vecDoublePt> _hydroUnitFractionsPt;
    vecInt _subbasinEtIndices;   // indices into _subbasinValues that are ET (to-atmosphere) fluxes
    vecInt _hydroUnitEtIndices;  // indices into _hydroUnitValues that are ET (to-atmosphere) fluxes
 
  private:
    [[nodiscard]] double WeightedTotal(int iLabel) const;
 
    [[nodiscard]] int GetSubbasinIndex(int subbasinId) const;
 
    [[nodiscard]] int GetOutletLabelIndex() const;
};
 
#endif  // HYDROBRICKS_LOGGER_H