timeseries.h

Go to the documentation of this file.

#ifndef MOJA_MODULES_CBM_TIMESERIES_H_
#define MOJA_MODULES_CBM_TIMESERIES_H_
 
#include <moja/flint/itiming.h>
 
#include "moja/modules/cbm/_modules.cbm_exports.h"
 
#include <boost/optional.hpp>
#include <vector>
 
namespace moja {
namespace modules {
namespace cbm {
 
enum class ExtrapType {
    NearestYr = 0,
    CycleYrs,
    AvgYr
};
 
 
enum class DateOrigin {
    Calendar = 0,
    StartSim,
    Sprout
};
 
enum class Frequency {
    Annual,
    Monthly,
    Daily,
    Observations
};
 
enum class InterpType {
    Linear,
    ColAverage
};
 
enum class SubSamplingMode {
    None,
    Interpolate
};
 
class CBM_API TimeSeries {
public:
    TimeSeries();
 
    TimeSeries(int yr0, int dataPerYr, int nYrs, bool subSame,
               const std::vector<boost::optional<double>> raw,
               DateOrigin origin = DateOrigin::StartSim,
               int extraSteps = 0);
 
    ~TimeSeries() = default;
 
    void setTiming(const flint::ITiming* timing);
 
    void setTiming(DateTime start, DateTime end);
 
    const std::vector<double>& series() const;
 
    double value() const;
 
    int yr0() const;
 
    int nYrs() const;
 
    int dataPerYr() const;
 
    bool subSame() const;
 
    const std::vector<boost::optional<double>> raw() const;
 
    DateOrigin origin() const;
 
    ExtrapType extrap() const;
 
private:
    class TimeSeriesPrep;
    std::shared_ptr<TimeSeriesPrep> _impl;
};
 
struct CORE_API Observation {
    DateTime date;
    boost::optional<double> value;
};
 
class CORE_API TimeSeries2 {
public:
    TimeSeries2() : _interpType(InterpType::ColAverage),
                    _extraptype(ExtrapType::NearestYr),
                    _frequency(Frequency::Monthly),
                    _multiplier(1.0) {}
 
    TimeSeries2(DateTime start,
                const std::vector<boost::optional<double>>& data,
                Frequency frequency = Frequency::Monthly,
                ExtrapType extraptype = ExtrapType::NearestYr,
                InterpType interpType = InterpType::ColAverage) :
        _interpType(interpType), _extraptype(extraptype), _frequency(frequency),
        _start(start), _multiplier(1.0), _series(data) {}
 
    explicit TimeSeries2(const std::vector<Observation>& observations,
                         ExtrapType extraptype = ExtrapType::NearestYr,
                         InterpType interpType = InterpType::Linear) :
        _interpType(interpType), _extraptype(extraptype), _frequency(Frequency::Observations),
        _multiplier(1.0), _observations(observations) {}
 
    void setData(DateTime start,
                 const std::vector<boost::optional<double>>& data,
                 Frequency frequency = Frequency::Monthly) {}
 
    void setObservations(const std::vector<Observation>& observations) {}
    void addObservation(Observation observation) {}
 
    double multiplier() const;
    void setMultiplier(double multiplier);
 
    std::vector<Observation> observations() const;
    std::vector<double> series(DateTime start, DateTime end) const;
    double value() const; // by age(duration??) for date???
 
    ExtrapType extrapType() const;
    void setExtrapType(ExtrapType extraptype);
 
    InterpType interpType() const;
    void setInterpType(InterpType interpType);
 
    Frequency frequency() const;
 
private:
    InterpType _interpType;
    ExtrapType _extraptype;
    Frequency _frequency;
    DateTime _start;
    double _multiplier; 
    std::vector<boost::optional<double>> _series;
    std::vector<Observation> _observations;
};
 
inline double TimeSeries2::multiplier() const {
    return _multiplier;
}
 
inline void TimeSeries2::setMultiplier(double multiplier) {
    _multiplier = multiplier;
}
 
inline std::vector<Observation> TimeSeries2::observations() const {
    switch (_frequency)
    {
    case Frequency::Observations: {
        return _observations;
    } break;
    case Frequency::Annual:  {
        auto observations = std::vector<Observation>();
        auto date = _start;
        for (auto value : _series) {
            // Represents the end of the annual step.
            auto observationDate = DateTime(date.year() + 1, 1, 1).addMicroseconds(-1);
            observations.push_back({ observationDate, value });
            date.addYears(1);
        }
        return observations;
    } break;
    case Frequency::Monthly: {
        auto observations = std::vector<Observation>();
        auto date = _start;
        for (auto value : _series) {
            // Represents the end of the monthly step.
            auto observationDate = DateTime(date.year(), date.month(), 1).addMonths(1).addMicroseconds(-1);
            observations.push_back({ observationDate, value });
            date.addMonths(1);
        }
        return observations;
    } break;
    case Frequency::Daily: break;
    default: break;
    }
    return std::vector<Observation>();
}
 
inline std::vector<double> TimeSeries2::series(DateTime start, DateTime end) const {
    // - Later interpolations and extrapolations require the TS table to be complete.
    // - Empty cells are assigned the average of the column.
    auto dataPerYr = -1;
    switch (_frequency)
    {
    case Frequency::Annual: dataPerYr = 1; break;
    case Frequency::Monthly: dataPerYr = 12; break;
    default: break;
    }
    auto nYrs = _series.size() / dataPerYr;
 
    std::vector<double> result(_series.size());
    for (auto c = 0; c < dataPerYr; ++c) { // Calculate col sum
        double colAvg = 0.0;
        int n = 0;
        int ix = c;
        for (auto r = 0; r < nYrs; ++r) {
            if (_series[ix].is_initialized()) {
                colAvg += _series[ix].get();
                ++n;
            }
            ix += dataPerYr;
        }
 
        if (n == 0) {
            throw std::runtime_error("No data for timeseries column");
        }
 
        colAvg /= n;
        ix = c;
        for (auto r = 0; r < nYrs; ++r) {
            result[ix] = (_series[ix].is_initialized() ? _series[ix].get() : colAvg) * _multiplier;
            ix += dataPerYr;
        }
    }
        
    return std::vector<double>();
}
 
inline double TimeSeries2::value() const {
    return 0.0;
}
 
inline ExtrapType TimeSeries2::extrapType() const {
    return _extraptype;
}
 
inline void TimeSeries2::setExtrapType(ExtrapType extraptype) {
    _extraptype = extraptype;
}
 
inline InterpType TimeSeries2::interpType() const {
    return _interpType;
}
 
inline void TimeSeries2::setInterpType(InterpType interpType) {
    _interpType = interpType;
}
 
inline Frequency TimeSeries2::frequency() const {
    return _frequency;
}
 
} // namespace cbm
} // namespace modules
} // namespace moja
 
#endif // MOJA_MODULES_CBM_TIMESERIES_H_