boundaryconditions.hpp

#pragma once
 
#include <ostream>
#include <vector>
#include <string>
#include <armadillo>
 
#include "composition.hpp"
 
class Pipeline;
 
class BoundaryConditions
{
public:
    BoundaryConditions();
 
    explicit BoundaryConditions(
            const arma::mat& boundaryConditionMat,
            const Composition& inletComposition = Composition::defaultComposition,
            const Composition& outletComposition = Composition::defaultComposition);
 
    BoundaryConditions(
            const double inletFlow,
            const double outletFlow,
            const double inletPressure,
            const double outletPressure,
            const double inletTemperature,
            const double outletTemperature,
            const Composition& inletComposition = Composition::defaultComposition,
            const Composition& outletComposition = Composition::defaultComposition);
 
    explicit BoundaryConditions(
            const Pipeline& pipeline,
            const std::vector<std::string>& boundarySettings = {"inlet", "outlet", "inlet"});
 
    void setBoundarySettings(const std::vector<std::string>& strings);
 
    arma::uword nActiveBoundaryConditions() const;
 
    // getters
    inline const auto& inletFlow() const { return m_inletFlow; } 
    inline const auto& outletFlow() const { return m_outletFlow; } 
 
    inline const auto& inletPressure() const { return m_inletPressure; } 
    inline const auto& outletPressure() const { return m_outletPressure; } 
 
    inline const auto& inletTemperature() const { return m_inletTemperature; } 
    inline const auto& outletTemperature() const { return m_outletTemperature; } 
 
    inline const Composition& inletComposition() const { return m_inletComposition; } 
    inline const Composition& outletComposition() const { return m_outletComposition; } 
 
    // setters
    inline auto& inletFlow() { return m_inletFlow; } 
    inline auto& outletFlow() { return m_outletFlow; } 
 
    inline auto& inletPressure() { return m_inletPressure; } 
    inline auto& outletPressure() { return m_outletPressure; } 
 
    inline auto& inletTemperature() { return m_inletTemperature; } 
    inline auto& outletTemperature() { return m_outletTemperature; } 
 
    inline Composition& inletComposition() { return m_inletComposition; } 
    inline Composition& outletComposition() { return m_outletComposition; } 
 
    inline const auto& inlet(const arma::uword i) const
    {
        if (i == 0)
            return inletFlow();
        else if (i == 1)
            return inletPressure();
        else if (i == 2)
            return inletTemperature();
        else
            throw std::runtime_error("invalid index i");
    }
 
    inline const auto& outlet(const arma::uword i) const
    {
        if (i == 0)
            return outletFlow();
        else if (i == 1)
            return outletPressure();
        else if (i == 2)
            return outletTemperature();
        else
            throw std::runtime_error("invalid index i");
    }
 
    friend std::ostream& operator << (std::ostream &out, const BoundaryConditions& c);
 
    class SingleCondition
    {
    public:
        friend class BoundaryConditions;
 
        SingleCondition(const double value, const bool active):
            m_value(value),
            m_isActive(active)
        {}
 
        inline operator double() const { return m_value; }
 
        inline operator double() { return m_value; }
 
        double value() const { return m_value; }
 
        double value() { return m_value; }
 
        bool isActive() const { return m_isActive; }
 
        bool isActive() { return m_isActive; }
 
    private:
        void setActive(const bool active) { m_isActive = active; }
 
        double m_value; 
        bool m_isActive; 
    };
 
    BoundaryConditions(
            const SingleCondition inletFlow,
            const SingleCondition outletFlow,
            const SingleCondition inletPressure,
            const SingleCondition outletPressure,
            const SingleCondition inletTemperature,
            const SingleCondition outletTemperature,
            const Composition& inletComposition = Composition::defaultComposition,
            const Composition& outletComposition = Composition::defaultComposition);
 
private:
    SingleCondition m_inletFlow; 
    SingleCondition m_inletPressure; 
    SingleCondition m_inletTemperature; 
    SingleCondition m_outletFlow; 
    SingleCondition m_outletPressure; 
    SingleCondition m_outletTemperature; 
 
    Composition m_inletComposition; 
    Composition m_outletComposition; 
 
    void setBoundarySettings(const arma::uword i, const std::string& setting)
    {
        if (setting == "none")
        {
            this->inlet(i).setActive(false);
            this->outlet(i).setActive(false);
        }
        else if (setting == "inlet")
        {
            this->inlet(i).setActive(true);
            this->outlet(i).setActive(false);
        }
        else if (setting == "outlet")
        {
            this->inlet(i).setActive(false);
            this->outlet(i).setActive(true);
        }
        else if (setting == "both")
        {
            this->inlet(i).setActive(true);
            this->outlet(i).setActive(true);
        }
        else
        {
            throw std::runtime_error("invalid setting \"" + setting + "\"");
        }
    }
 
    inline SingleCondition& inlet(const arma::uword i)
    {
        if (i == 0)
            return inletFlow();
        else if (i == 1)
            return inletPressure();
        else if (i == 2)
            return inletTemperature();
        else
            throw std::runtime_error("invalid index i");
    }
 
    inline SingleCondition& outlet(const arma::uword i)
    {
        if (i == 0)
            return outletFlow();
        else if (i == 1)
            return outletPressure();
        else if (i == 2)
            return outletTemperature();
        else
            throw std::runtime_error("invalid index i");
    }
};
 
class TimeStep : public BoundaryConditions
{
public:
    TimeStep(
            const arma::uword timestamp,
            const BoundaryConditions& boundaryConditions):
        BoundaryConditions(boundaryConditions),
        m_timestamp(timestamp)
    {}
 
    arma::uword timestamp() const { return m_timestamp; }
 
private:
    arma::uword m_timestamp; 
};