OpeningLosses.h

Go to the documentation of this file.

#ifndef AMO_SUITE_OPENINGLOSSES_H
#define AMO_SUITE_OPENINGLOSSES_H

#include <functional>
#include <array>

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
            }
    };
};
#endif //AMO_SUITE_OPENINGLOSSES_H