timeseries.hpp

#pragma once
 
#include <iostream>
#include <vector>
#include <string>
#include <armadillo>
 
#include "composition.hpp"
 
class Pipeline;
class BoundaryConditions;
class TimeStep;
 
class TimeSeries
{
public:
    TimeSeries(const arma::uword nSteps, const arma::uword dt = 60);
 
    TimeSeries(const arma::uvec& timestamps);
 
    TimeSeries(
            const Pipeline& pipeline,
            const arma::uword nSteps,
            const arma::uword dt = 60,
            const std::vector<std::string>& boundarySettings = {"inlet", "outlet", "inlet"});
 
    TimeSeries(
            const std::string& filename,
            const std::vector<std::string>& boundarySettings = {"inlet", "outlet", "inlet"});
 
    TimeSeries(
            const std::string& filename,
            arma::uword lastRow,
            const std::vector<std::string>& boundarySettings = {"inlet", "outlet", "inlet"});
 
    TimeSeries(
            const std::string& filename,
            arma::uword firstRow,
            arma::uword lastRow,
            const std::vector<std::string>& boundarySettings = {"inlet", "outlet", "inlet"});
 
    TimeSeries(
            const arma::mat& data,
            const std::vector<std::string>& boundarySettings = {"inlet", "outlet", "inlet"});
 
    TimeSeries(
            const arma::uvec& timestamps,
            const std::vector<BoundaryConditions>& boundaryConditions);
 
    TimeSeries(
            const arma::uword dt,
            const std::vector<BoundaryConditions>& boundaryConditions);
 
    void setBoundarySettings(const std::vector<std::string> settings);
 
    void save(const std::string& filename);
 
    // getters
    const auto& timestamps() const { return m_timestamps; }
    const std::vector<Composition>& inletComposition() const { return m_inletComposition; }
    const std::vector<Composition>& outletComposition() const { return m_outletComposition; }
 
    const auto& inletFlow()         const { return m_inletFlow; } 
    const auto& inletPressure()     const { return m_inletPressure; } 
    const auto& inletTemperature()  const { return m_inletTemperature; } 
    const auto& outletFlow()        const { return m_outletFlow; } 
    const auto& outletPressure()    const { return m_outletPressure; } 
    const auto& outletTemperature() const { return m_outletTemperature; } 
 
    // getters/setters
    auto& timestamps() { return m_timestamps; }
    std::vector<Composition>& inletComposition() { return m_inletComposition; }
    std::vector<Composition>& outletComposition() { return m_outletComposition; }
 
    auto& inletFlow()         { return m_inletFlow; } 
    auto& inletPressure()     { return m_inletPressure; } 
    auto& inletTemperature()  { return m_inletTemperature; } 
    auto& outletFlow()        { return m_outletFlow; } 
    auto& outletPressure()    { return m_outletPressure; } 
    auto& outletTemperature() { return m_outletTemperature; } 
 
    operator std::vector<TimeStep>() const;
 
    TimeStep at(std::size_t pos) const;
 
    arma::uword size() const { return m_timestamps.n_rows; }
 
    class Series
    {
    public:
        friend class TimeSeries;
 
        Series(const bool active=false):
            m_isActive(active)
        {}
 
        Series(const arma::vec& value):
            m_isActive(true),
            m_vec(value)
        {}
 
        Series(const arma::vec& value, const bool active):
            m_isActive(active),
            m_vec(value)
        {}
 
        void set(const arma::vec& value)
        {
            m_isActive = true;
            m_vec = value;
        }
 
        void set(const arma::vec& value, const bool active)
        {
            m_isActive = active;
            m_vec = value;
        }
 
        void fill(const double value)
        {
            m_isActive = true;
            m_vec.fill(value);
        }
 
        void setActive(const bool active)
        {
            m_isActive = active;
        }
 
        // copy assignment operator
        Series& operator= (const arma::vec& value)
        {
            m_vec = value;
            m_isActive = true;
 
            return *this;
        }
 
        double operator()(const arma::uword i) const { return m_vec(i); }
 
        arma::uword size() const { return m_vec.n_elem; }
 
        bool isActive() const { return m_isActive; }
 
        bool isActive() { return m_isActive; }
 
        const arma::vec& vec() const { return m_vec; }
 
    private:
        arma::vec& vec() { return m_vec; }
 
        bool m_isActive = false;
 
        arma::vec m_vec; // not initialized
    };
 
private:
    arma::uvec m_timestamps; 
 
    Series m_inletFlow; 
    Series m_inletPressure; 
    Series m_inletTemperature; 
    Series m_outletFlow; 
    Series m_outletPressure; 
    Series m_outletTemperature; 
 
    std::vector<Composition> m_inletComposition; 
    std::vector<Composition> m_outletComposition; 
 
    void loadFromMatrix(const arma::mat& bc);
};