opening_losses.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cmath>
#include <functional>
#include <stdexcept>
 
class OpeningLosses {
  public:
    enum class OpeningShape { CIRCULAR, RECTANGULAR };
 
    double calculateViewFactor(double thickness, double diameter);
 
    double calculateViewFactor(double thickness, double length, double height);
 
    OpeningLosses(double emissivity, double length, double width, double thickness, double ratio,
                  double ambientTemperature, double insideTemperature, double percentTimeOpen, double viewFactor)
        : emissivity(emissivity), length(length), width(width), thickness(thickness), ratio(ratio),
          ambientTemperature(ambientTemperature), insideTemperature(insideTemperature),
          percentTimeOpen(percentTimeOpen), viewFactor(viewFactor), openingShape(OpeningShape::RECTANGULAR) {}
 
    OpeningLosses(double emissivity, double diameter, double thickness, double ratio, double ambientTemperature,
                  double insideTemperature, double percentTimeOpen, double viewFactor)
        : emissivity(emissivity), diameter(diameter), thickness(thickness), ratio(ratio),
          ambientTemperature(ambientTemperature), insideTemperature(insideTemperature),
          percentTimeOpen(percentTimeOpen), viewFactor(viewFactor), openingShape(OpeningShape::CIRCULAR) {}
 
    OpeningLosses() = default;
 
    double getEmissivity() const { return emissivity; }
 
    void setEmissivity(double emissivity) { this->emissivity = emissivity; }
 
    double getDiameter() const { return diameter; }
 
    void setDiameter(double diameter) { this->diameter = diameter; }
 
    double getWidth() const { return width; }
 
    void setWidth(double width) { this->width = width; }
 
    double getThickness() const { return thickness; }
 
    void setThickness(double thickness) { this->thickness = thickness; }
 
    double getRatio() const { return ratio; }
 
    void setRatio(double ratio) { this->ratio = ratio; }
 
    double getAmbientTemperature() const { return ambientTemperature; }
 
    void setAmbientTemperature(double ambientTemperature) { this->ambientTemperature = ambientTemperature; }
 
    double getInsideTemperature() const { return insideTemperature; }
 
    void setInsideTemperature(double insideTemperature) { this->insideTemperature = insideTemperature; }
 
    double getPercentTimeOpen() const { return percentTimeOpen; }
 
    void setPercentTimeOpen(double percentTimeOpen) { this->percentTimeOpen = percentTimeOpen; }
 
    double getViewFactor() const { return viewFactor; }
 
    void setViewFactor(double viewFactor) { this->viewFactor = viewFactor; }
 
    OpeningShape getOpeningShape() const { return openingShape; }
 
    void setOpeningShape(OpeningShape const openingShape, const double length, const double width) {
        if (openingShape != OpeningShape::RECTANGULAR) {
            throw std::runtime_error("Call the other set opening shape function to set openingShape to Circular");
        }
        this->openingShape = openingShape;
        this->length       = length;
        this->width        = width;
        diameter           = 0;
    }
 
    void setOpeningShape(OpeningShape const openingShape, const double diameter) {
        if (openingShape != OpeningShape::CIRCULAR) {
            throw std::runtime_error("Call the other set opening shape function to set openingShape to Rectangular");
        }
        this->openingShape = openingShape;
        this->diameter     = diameter;
        length             = 0;
        width              = 0;
    }
 
    double getHeatLoss();
 
  private:
    double       emissivity = 0.95;
    double       diameter   = 0;
    double       length = 0, width = 0;
    double       thickness;
    double       ratio;
    double       ambientTemperature;
    double       insideTemperature;
    double       percentTimeOpen;
    double       viewFactor;
    OpeningShape openingShape;
 
    double heatLoss = 0;
 
    const std::array<const std::function<double(const double thicknessRatio)>, 8> viewFactorEquations = {{
        [](const double tr) {
            return (1.10000000001829 + 92.8571428570049 * tr - 57.5892857139671 * std::pow(tr, 2) +
                    15.6249999998005 * std::pow(tr, 3)) /
                   100;
        }, // case 1
        [](const double tr) {
            return (29.4999999989821 + 26.8416666684161 * tr - 4.35416666785322 * std::pow(tr, 2) -
                    8.33333330461522E-02 * std::pow(tr, 3) + 0.104166666655532 * std::pow(tr, 4) -
                    8.33333333686747E-03 * std::pow(tr, 5)) /
                   100;
        }, // case 2
        [](const double tr) {
            return (3.50000000001719 + 89.5833333332039 * tr - 49.9999999997023 * std::pow(tr, 2) +
                    10.4166666664804 * std::pow(tr, 3)) /
                   100;
        }, // case 3
        [](const double tr) {
            return (23.9999999965639 + 39.3916666718743 * tr - 11.6041666697487 * std::pow(tr, 2) +
                    1.85416666706894 * std::pow(tr, 3) - 0.145833333217932 * std::pow(tr, 4) +
                    4.16666663902102E-03 * std::pow(tr, 5)) /
                   100;
        }, // case 4
        [](const double tr) {
            return (2.70000000002409 + 112.678571428391 * tr - 70.9821428567315 * std::pow(tr, 2) +
                    15.6249999997447 * std::pow(tr, 3)) /
                   100;
        }, // case 5
        [](const double tr) {
            return (35.4999999992976 + 29.4583333347815 * tr - 4.52083333446976 * std::pow(tr, 2) -
                    0.687499999606652 * std::pow(tr, 3) + 0.270833333273064 * std::pow(tr, 4) -
                    2.08333333303721E-02 * std::pow(tr, 5)) /
                   100;
        }, // case 6
        [](const double tr) {
            return (13.0000000000278 + 123.74999999979 * tr - 99.9999999995182 * std::pow(tr, 2) +
                    31.249999999699 * std::pow(tr, 3)) /
                   100;
        }, // case 7
        [](const double tr) {
            return (26.9999999903567 + 64.5666666806646 * tr - 29.9166666745008 * std::pow(tr, 2) +
                    7.14583333396145 * std::pow(tr, 3) - 0.833333332874441 * std::pow(tr, 4) +
                    3.74999999085373E-02 * std::pow(tr, 5)) /
                   100;
        }, // case 8
    }};
};