pipewall.hpp

#pragma once
 
#include <vector>
#include <armadillo>
 
#include "material.hpp"
 
class PipeWall
{
public:
    class Layer;
 
    explicit PipeWall(const arma::uword nWallLayers):
        m_layers(std::vector<Layer>(nWallLayers))
    {}
 
    explicit PipeWall(const std::vector<Layer>& wallLayers):
        m_layers(wallLayers)
    {}
 
    const Layer& layer(const arma::uword i) const
    {
        return m_layers.at(i);
    }
 
    Layer& layer(const arma::uword i)
    {
        return m_layers.at(i);
    }
 
    const std::vector<Layer>& layers() const { return m_layers; }
 
    arma::uword size() const { return m_layers.size(); }
 
    // initialized in .cpp
    static const PipeWall defaultPipeWall; 
 
private:
    std::vector<Layer> m_layers;
};
 
class PipeWall::Layer : public Material
{
public:
    constexpr Layer():
        Material(-1, -1, -1),
        m_thickness(-1)
    {}
 
    constexpr Layer(
            const double thickness,
            const double conductivity,
            const double density,
            const double heatCapacity):
        Material(conductivity, density, heatCapacity),
        m_thickness(thickness)
    {}
 
    constexpr Layer(
            const double thickness,
            const Material& material):
        Material(material),
        m_thickness(thickness)
    {}
 
    double thickness() const { return m_thickness; } 
    double conductivity() const { return m_conductivity; } 
    double density() const { return m_density; } 
    double heatCapacity() const { return m_heatCapacity; } 
 
    // setters
    double& thickness() { return m_thickness; } 
    double& conductivity() { return m_conductivity; } 
    double& density() { return m_density; } 
    double& heatCapacity() { return m_heatCapacity; } 
 
private:
    double m_thickness; 
};