From 3e1e6a4c6507a941cef18a03726f90bfee6e8ea9 Mon Sep 17 00:00:00 2001 From: Simon Wacker Date: Tue, 22 Nov 2022 13:28:59 +0100 Subject: [PATCH] Use closed shades to model sealed forced-ventilation gaps --- src/Tarcog/src/IGU.cpp | 14 ---- src/Tarcog/src/IGUVentilatedGapLayer.cpp | 72 ------------------- src/Tarcog/src/IGUVentilatedGapLayer.hpp | 4 -- src/Tarcog/src/Layers.cpp | 16 +++++ src/Tarcog/src/Layers.hpp | 8 +++ .../GapLayerSealedForcedVentilation.unit.cpp | 55 +++++++------- ...ayerSealedForcedVentilationNarrow.unit.cpp | 55 +++++++------- ...VentilationNarrowWithZeroAirSpeed.unit.cpp | 35 ++++----- 8 files changed, 98 insertions(+), 161 deletions(-) diff --git a/src/Tarcog/src/IGU.cpp b/src/Tarcog/src/IGU.cpp index 6f493060..f9b9f342 100644 --- a/src/Tarcog/src/IGU.cpp +++ b/src/Tarcog/src/IGU.cpp @@ -534,22 +534,8 @@ namespace Tarcog } if(std::dynamic_pointer_cast(t_Layer) != nullptr) { - auto gap = std::dynamic_pointer_cast(t_Layer); if(std::dynamic_pointer_cast(t_Layer->getPreviousLayer()) != nullptr) - { - auto newLayer = std::make_shared(gap); - replaceLayer(std::dynamic_pointer_cast(t_Layer), newLayer); - } - else if(gap->isVentilationForced() - && std::dynamic_pointer_cast(t_Layer->getPreviousLayer()) - != nullptr - && std::dynamic_pointer_cast(t_Layer->getPreviousLayer()) - == nullptr - && std::dynamic_pointer_cast(t_Layer->getNextLayer()) - != nullptr - && std::dynamic_pointer_cast(t_Layer->getNextLayer()) - == nullptr) { auto newLayer = std::make_shared( std::dynamic_pointer_cast(t_Layer)); diff --git a/src/Tarcog/src/IGUVentilatedGapLayer.cpp b/src/Tarcog/src/IGUVentilatedGapLayer.cpp index f88b016b..2dcefb09 100644 --- a/src/Tarcog/src/IGUVentilatedGapLayer.cpp +++ b/src/Tarcog/src/IGUVentilatedGapLayer.cpp @@ -3,13 +3,8 @@ #include #include -#include "BaseShade.hpp" -#include "TarcogConstants.hpp" #include "IGUVentilatedGapLayer.hpp" #include "WCEGases.hpp" -#include "WCECommon.hpp" - -using FenestrationCommon::Side; namespace Tarcog { @@ -159,77 +154,10 @@ namespace Tarcog CIGUGapLayer::calculateConvectionOrConductionFlow(); if(!isCalculated()) { - if(isVentilationForced() && m_NextLayer != nullptr && m_PreviousLayer != nullptr - && std::dynamic_pointer_cast(m_PreviousLayer) != nullptr - && std::dynamic_pointer_cast(m_PreviousLayer) == nullptr - && std::dynamic_pointer_cast(m_NextLayer) != nullptr - && std::dynamic_pointer_cast(m_NextLayer) == nullptr) - { - auto previousSolidLayer = - std::dynamic_pointer_cast(m_PreviousLayer); - auto nextSolidLayer = std::dynamic_pointer_cast(m_NextLayer); - calcSealedForcedVentilationGapTemperatures(previousSolidLayer, nextSolidLayer); - } ventilatedFlow(); } } - void CIGUVentilatedGapLayer::calcSealedForcedVentilationGapTemperatures( - std::shared_ptr t_PreviousLayer, - std::shared_ptr t_NextLayer) - { - // Inspired by `CIGUShadeLayer::calcEdgeShadeFlow` - double TgapOut = layerTemperature(); - double RelaxationParameter = IterationConstants::RELAXATION_PARAMETER_AIRFLOW; - bool converged = false; - size_t iterationStep = 0; - - double tempGap = layerTemperature(); - ForcedVentilation forcedVentilation = getForcedVentilation(); - setFlowSpeed(forcedVentilation.Speed); - // m_AirSpeed = forcedVentilation.Speed; - double tempPreviousLayer = t_PreviousLayer->getTemperature(Side::Back); - while(!converged) - { - double TavGap = averageTemperature(); - // To calculate `beta` we do not invoke `betaCoeff` because - // doing so results in an infinite recursion as it calls - // `calculateLayerHeatFlow`, which calls - // `calculateConvectionOrConductionFlow`, which calls this - // method. - double beta = exp(-m_Height / characteristicHeight()); - double alpha = 1 - beta; - - double TgapOutOld = TgapOut; - - TgapOut = alpha * TavGap + beta * tempPreviousLayer; - - setFlowTemperatures(tempPreviousLayer, TgapOut); - // m_inTemperature = tempPreviousLayer; - // m_outTemperature = TgapOut; - - tempGap = layerTemperature(); - - TgapOut = RelaxationParameter * tempGap + (1 - RelaxationParameter) * TgapOutOld; - - converged = std::abs(TgapOut - TgapOutOld) - < IterationConstants::CONVERGENCE_TOLERANCE_AIRFLOW; - - ++iterationStep; - if(iterationStep > IterationConstants::NUMBER_OF_STEPS) - { - RelaxationParameter -= IterationConstants::RELAXATION_PARAMETER_AIRFLOW_STEP; - iterationStep = 0; - if(RelaxationParameter == IterationConstants::RELAXATION_PARAMETER_AIRFLOW_MIN) - { - converged = true; - throw std::runtime_error("Airflow iterations fail to converge. " - "Maximum number of iteration steps reached."); - } - } - } - } - double CIGUVentilatedGapLayer::characteristicHeight() { const auto aProperties = m_Gas.getGasProperties(); diff --git a/src/Tarcog/src/IGUVentilatedGapLayer.hpp b/src/Tarcog/src/IGUVentilatedGapLayer.hpp index 6f539224..0d5bd87a 100644 --- a/src/Tarcog/src/IGUVentilatedGapLayer.hpp +++ b/src/Tarcog/src/IGUVentilatedGapLayer.hpp @@ -3,7 +3,6 @@ #include -#include "BaseShade.hpp" #include "WCEGases.hpp" #include "IGUGapLayer.hpp" @@ -42,9 +41,6 @@ namespace Tarcog double characteristicHeight(); double calcImpedance(double t_A) const; void ventilatedFlow(); - void calcSealedForcedVentilationGapTemperatures( - std::shared_ptr t_PreviousLayer, - std::shared_ptr t_NextLayer); std::shared_ptr m_Layer; Gases::CGas m_ReferenceGas; diff --git a/src/Tarcog/src/Layers.cpp b/src/Tarcog/src/Layers.cpp index 82de0bcc..d0d3071c 100644 --- a/src/Tarcog/src/Layers.cpp +++ b/src/Tarcog/src/Layers.cpp @@ -92,6 +92,22 @@ namespace Tarcog std::make_shared(backEmissivity, backTransmittance)); } + std::shared_ptr Layers::closedShading(double thickness, + double conductivity, + double frontEmissivity, + double frontTransmittance, + double backEmissivity, + double backTransmittance) + { + return std::make_shared( + thickness, + conductivity, + std::make_shared(0, 0, 0, 0, 0, 0), + std::make_shared(frontEmissivity, frontTransmittance), + std::make_shared(backEmissivity, backTransmittance)); + } + + std::shared_ptr Layers::addCircularPillar(const std::shared_ptr & gap, double conductivity, diff --git a/src/Tarcog/src/Layers.hpp b/src/Tarcog/src/Layers.hpp index dc320956..f60b62aa 100644 --- a/src/Tarcog/src/Layers.hpp +++ b/src/Tarcog/src/Layers.hpp @@ -6,6 +6,7 @@ #include "EffectiveOpenness.hpp" #include "LayerInterfaces.hpp" #include "TarcogConstants.hpp" +#include "BaseShade.hpp" namespace Tarcog { @@ -40,6 +41,13 @@ namespace Tarcog double backEmissivity = 0.84, double backTransmittance = 0.0); + static std::shared_ptr closedShading(double thickness, + double conductivity, + double frontEmissivity = 0.84, + double frontTransmittance = 0.0, + double backEmissivity = 0.84, + double backTransmittance = 0.0); + static std::shared_ptr gap(double thickness, double pressure = 101325); static std::shared_ptr gap(double thickness, const Gases::CGas & gas, double pressure = 101325); diff --git a/src/Tarcog/tst/units/GapLayerSealedForcedVentilation.unit.cpp b/src/Tarcog/tst/units/GapLayerSealedForcedVentilation.unit.cpp index 9b81b50d..71096393 100644 --- a/src/Tarcog/tst/units/GapLayerSealedForcedVentilation.unit.cpp +++ b/src/Tarcog/tst/units/GapLayerSealedForcedVentilation.unit.cpp @@ -37,13 +37,13 @@ class TestGapLayerSealedForcedVentilation : public testing::Test auto solidLayerThickness = 0.005715; // [m] auto solidLayerConductance = 1.0; - auto solidLayer1 = + auto solidLayer = Tarcog::ISO15099::Layers::solid(solidLayerThickness, solidLayerConductance); - ASSERT_TRUE(solidLayer1 != nullptr); + ASSERT_TRUE(solidLayer != nullptr); - auto solidLayer2 = - Tarcog::ISO15099::Layers::solid(solidLayerThickness, solidLayerConductance); - ASSERT_TRUE(solidLayer2 != nullptr); + auto closedShadeLayer = + Tarcog::ISO15099::Layers::closedShading(solidLayerThickness, solidLayerConductance); + ASSERT_TRUE(closedShadeLayer != nullptr); auto gapThickness = 0.0127; auto gapAirSpeed = 0.5; @@ -54,7 +54,7 @@ class TestGapLayerSealedForcedVentilation : public testing::Test double windowWidth = 1; double windowHeight = 1; Tarcog::ISO15099::CIGU aIGU(windowWidth, windowHeight); - aIGU.addLayers({solidLayer1, gap, solidLayer2}); + aIGU.addLayers({solidLayer, gap, closedShadeLayer}); ///////////////////////////////////////////////////////// /// System @@ -66,7 +66,7 @@ class TestGapLayerSealedForcedVentilation : public testing::Test } public: - std::shared_ptr GetSolidLayer1() const + std::shared_ptr GetSolidLayer() const { auto solidLayer = m_TarcogSystem->getSolidLayers()[0]; assert(std::dynamic_pointer_cast(solidLayer) != nullptr); @@ -80,11 +80,12 @@ class TestGapLayerSealedForcedVentilation : public testing::Test return std::dynamic_pointer_cast(gap); }; - std::shared_ptr GetSolidLayer2() const + std::shared_ptr GetClosedShadeLayer() const { - auto solidLayer = m_TarcogSystem->getSolidLayers()[1]; - assert(std::dynamic_pointer_cast(solidLayer) != nullptr); - return std::dynamic_pointer_cast(solidLayer); + auto closedShadeLayer = m_TarcogSystem->getSolidLayers()[1]; + assert(std::dynamic_pointer_cast(closedShadeLayer) + != nullptr); + return std::dynamic_pointer_cast(closedShadeLayer); }; }; @@ -98,22 +99,22 @@ TEST_F(TestGapLayerSealedForcedVentilation, GainEnergy) ASSERT_TRUE(aLayer != nullptr); auto gainEnergy = aLayer->getGainFlow(); - EXPECT_NEAR(-57.193291279467125, gainEnergy, 1e-4); + EXPECT_NEAR(132.26008267306551, gainEnergy, 1e-4); } -TEST_F(TestGapLayerSealedForcedVentilation, Solid1Temperatures) +TEST_F(TestGapLayerSealedForcedVentilation, SolidTemperatures) { - SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Gap Layer - Solid 1 Temperatures"); + SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Gap Layer - Solid Temperatures"); - auto aLayer = GetSolidLayer1(); + auto aLayer = GetSolidLayer(); // Airflow iterations are set to 1e-4 and it cannot exceed that precision ASSERT_TRUE(aLayer != nullptr); auto frontTemperature = aLayer->getTemperature(FenestrationCommon::Side::Front); auto backTemperature = aLayer->getTemperature(FenestrationCommon::Side::Back); - EXPECT_NEAR(257.88610911376719, frontTemperature, 1e-4); - EXPECT_NEAR(258.34294987245784, backTemperature, 1e-4); + EXPECT_NEAR(262.13857535301037, frontTemperature, 1e-4); + EXPECT_NEAR(263.30867938548238, backTemperature, 1e-4); } TEST_F(TestGapLayerSealedForcedVentilation, GapTemperatures) @@ -129,25 +130,25 @@ TEST_F(TestGapLayerSealedForcedVentilation, GapTemperatures) auto backTemperature = aLayer->getTemperature(FenestrationCommon::Side::Back); auto layerTemperature = aLayer->layerTemperature(); auto averageTemperature = aLayer->averageTemperature(); - EXPECT_NEAR(258.34294987245784, frontTemperature, 1e-4); - EXPECT_NEAR(276.01222466583204, backTemperature, 1e-4); - EXPECT_NEAR(262.42249308270669, layerTemperature, 1e-4); - EXPECT_NEAR(267.17758726914496, averageTemperature, 1e-4); + EXPECT_NEAR(263.30867938548238, frontTemperature, 1e-4); + EXPECT_NEAR(284.72087553180552, backTemperature, 1e-4); + EXPECT_NEAR(284.71692368656022, layerTemperature, 1e-4); + EXPECT_NEAR(274.01477745864395, averageTemperature, 1e-4); } -TEST_F(TestGapLayerSealedForcedVentilation, Solid2Temperatures) +TEST_F(TestGapLayerSealedForcedVentilation, ClosedShadeTemperatures) { - SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Gap Layer - Solid 2 Temperatures"); + SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Gap Layer - Closed Shade Temperatures"); - auto aLayer = GetSolidLayer2(); + auto aLayer = GetClosedShadeLayer(); // Airflow iterations are set to 1e-4 and it cannot exceed that precision ASSERT_TRUE(aLayer != nullptr); auto frontTemperature = aLayer->getTemperature(FenestrationCommon::Side::Front); auto backTemperature = aLayer->getTemperature(FenestrationCommon::Side::Back); - EXPECT_NEAR(276.01222466583204, frontTemperature, 1e-4); - EXPECT_NEAR(276.79592508330529, backTemperature, 1e-4); + EXPECT_NEAR(284.72087553180552, frontTemperature, 1e-4); + EXPECT_NEAR(285.13511319074695, backTemperature, 1e-4); } TEST_F(TestGapLayerSealedForcedVentilation, AirflowReferencePoint) @@ -160,5 +161,5 @@ TEST_F(TestGapLayerSealedForcedVentilation, AirflowReferencePoint) ASSERT_TRUE(aLayer != nullptr); auto airflowReferencePoint = aLayer->getAirflowReferencePoint(0.5); - EXPECT_NEAR(6911.4449859804226, airflowReferencePoint, 1e-4); + EXPECT_NEAR(6912.4781021678982, airflowReferencePoint, 1e-4); } diff --git a/src/Tarcog/tst/units/GapLayerSealedForcedVentilationNarrow.unit.cpp b/src/Tarcog/tst/units/GapLayerSealedForcedVentilationNarrow.unit.cpp index 2297a702..9a02992f 100644 --- a/src/Tarcog/tst/units/GapLayerSealedForcedVentilationNarrow.unit.cpp +++ b/src/Tarcog/tst/units/GapLayerSealedForcedVentilationNarrow.unit.cpp @@ -37,13 +37,13 @@ class TestGapLayerSealedForcedVentilationNarrow : public testing::Test auto solidLayerThickness = 0.005715; // [m] auto solidLayerConductance = 1.0; - auto solidLayer1 = + auto solidLayer = Tarcog::ISO15099::Layers::solid(solidLayerThickness, solidLayerConductance); - ASSERT_TRUE(solidLayer1 != nullptr); + ASSERT_TRUE(solidLayer != nullptr); - auto solidLayer2 = - Tarcog::ISO15099::Layers::solid(solidLayerThickness, solidLayerConductance); - ASSERT_TRUE(solidLayer2 != nullptr); + auto closedShadeLayer = + Tarcog::ISO15099::Layers::closedShading(solidLayerThickness, solidLayerConductance); + ASSERT_TRUE(closedShadeLayer != nullptr); auto gapThickness = 0.00001; auto gapAirSpeed = 0.5; @@ -54,7 +54,7 @@ class TestGapLayerSealedForcedVentilationNarrow : public testing::Test double windowWidth = 1; double windowHeight = 1; Tarcog::ISO15099::CIGU aIGU(windowWidth, windowHeight); - aIGU.addLayers({solidLayer1, gap, solidLayer2}); + aIGU.addLayers({solidLayer, gap, closedShadeLayer}); ///////////////////////////////////////////////////////// /// System @@ -66,7 +66,7 @@ class TestGapLayerSealedForcedVentilationNarrow : public testing::Test } public: - std::shared_ptr GetSolidLayer1() const + std::shared_ptr GetSolidLayer() const { auto solidLayer = m_TarcogSystem->getSolidLayers()[0]; assert(std::dynamic_pointer_cast(solidLayer) != nullptr); @@ -80,11 +80,12 @@ class TestGapLayerSealedForcedVentilationNarrow : public testing::Test return std::dynamic_pointer_cast(gap); }; - std::shared_ptr GetSolidLayer2() const + std::shared_ptr GetClosedShadeLayer() const { - auto solidLayer = m_TarcogSystem->getSolidLayers()[1]; - assert(std::dynamic_pointer_cast(solidLayer) != nullptr); - return std::dynamic_pointer_cast(solidLayer); + auto closedShadeLayer = m_TarcogSystem->getSolidLayers()[1]; + assert(std::dynamic_pointer_cast(closedShadeLayer) + != nullptr); + return std::dynamic_pointer_cast(closedShadeLayer); }; }; @@ -98,22 +99,22 @@ TEST_F(TestGapLayerSealedForcedVentilationNarrow, GainEnergy) ASSERT_TRUE(aLayer != nullptr); auto gainEnergy = aLayer->getGainFlow(); - EXPECT_NEAR(-0.00032377683741991229, gainEnergy, 1e-4); + EXPECT_NEAR(0.20811005263324936, gainEnergy, 1e-4); } -TEST_F(TestGapLayerSealedForcedVentilationNarrow, Solid1Temperatures) +TEST_F(TestGapLayerSealedForcedVentilationNarrow, SolidTemperatures) { - SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Narrow Gap Layer - Solid 1 Temperatures"); + SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Narrow Gap Layer - Solid Temperatures"); - auto aLayer = GetSolidLayer1(); + auto aLayer = GetSolidLayer(); // Airflow iterations are set to 1e-4 and it cannot exceed that precision ASSERT_TRUE(aLayer != nullptr); auto frontTemperature = aLayer->getTemperature(FenestrationCommon::Side::Front); auto backTemperature = aLayer->getTemperature(FenestrationCommon::Side::Back); - EXPECT_NEAR(262.8455712342456, frontTemperature, 1e-4); - EXPECT_NEAR(264.13464915091032, backTemperature, 1e-4); + EXPECT_NEAR(262.85101821411911, frontTemperature, 1e-4); + EXPECT_NEAR(264.14101319036905, backTemperature, 1e-4); } TEST_F(TestGapLayerSealedForcedVentilationNarrow, GapTemperatures) @@ -129,25 +130,25 @@ TEST_F(TestGapLayerSealedForcedVentilationNarrow, GapTemperatures) auto backTemperature = aLayer->getTemperature(FenestrationCommon::Side::Back); auto layerTemperature = aLayer->layerTemperature(); auto averageTemperature = aLayer->averageTemperature(); - EXPECT_NEAR(264.13464915091032, frontTemperature, 1e-4); - EXPECT_NEAR(264.23102533430392, backTemperature, 1e-4); - EXPECT_NEAR(264.18283724260709, layerTemperature, 1e-4); - EXPECT_NEAR(264.18283724260709, averageTemperature, 1e-4); + EXPECT_NEAR(264.14101319036905, frontTemperature, 1e-4); + EXPECT_NEAR(264.23737025927898, backTemperature, 1e-4); + EXPECT_NEAR(264.18921397365273, layerTemperature, 1e-4); + EXPECT_NEAR(264.18919172482401, averageTemperature, 1e-4); } -TEST_F(TestGapLayerSealedForcedVentilationNarrow, Solid2Temperatures) +TEST_F(TestGapLayerSealedForcedVentilationNarrow, ClosedShadeTemperatures) { - SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Narrow Gap Layer - Solid 2 Temperatures"); + SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Narrow Gap Layer - Closed Shade Temperatures"); - auto aLayer = GetSolidLayer2(); + auto aLayer = GetClosedShadeLayer(); // Airflow iterations are set to 1e-4 and it cannot exceed that precision ASSERT_TRUE(aLayer != nullptr); auto frontTemperature = aLayer->getTemperature(FenestrationCommon::Side::Front); auto backTemperature = aLayer->getTemperature(FenestrationCommon::Side::Back); - EXPECT_NEAR(264.23102533430392, frontTemperature, 1e-4); - EXPECT_NEAR(265.52010325096921, backTemperature, 1e-4); + EXPECT_NEAR(264.23737025927898, frontTemperature, 1e-4); + EXPECT_NEAR(265.52617588657745, backTemperature, 1e-4); } TEST_F(TestGapLayerSealedForcedVentilationNarrow, AirflowReferencePoint) @@ -160,5 +161,5 @@ TEST_F(TestGapLayerSealedForcedVentilationNarrow, AirflowReferencePoint) ASSERT_TRUE(aLayer != nullptr); auto airflowReferencePoint = aLayer->getAirflowReferencePoint(0.5); - EXPECT_NEAR(6911.5329001843065, airflowReferencePoint, 1e-4); + EXPECT_NEAR(6911.5332165180625, airflowReferencePoint, 1e-4); } diff --git a/src/Tarcog/tst/units/GapLayerSealedForcedVentilationNarrowWithZeroAirSpeed.unit.cpp b/src/Tarcog/tst/units/GapLayerSealedForcedVentilationNarrowWithZeroAirSpeed.unit.cpp index cb878d6f..41b58a5a 100644 --- a/src/Tarcog/tst/units/GapLayerSealedForcedVentilationNarrowWithZeroAirSpeed.unit.cpp +++ b/src/Tarcog/tst/units/GapLayerSealedForcedVentilationNarrowWithZeroAirSpeed.unit.cpp @@ -37,13 +37,13 @@ class TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed : public testing auto solidLayerThickness = 0.005715; // [m] auto solidLayerConductance = 1.0; - auto solidLayer1 = + auto solidLayer = Tarcog::ISO15099::Layers::solid(solidLayerThickness, solidLayerConductance); - ASSERT_TRUE(solidLayer1 != nullptr); + ASSERT_TRUE(solidLayer != nullptr); - auto solidLayer2 = - Tarcog::ISO15099::Layers::solid(solidLayerThickness, solidLayerConductance); - ASSERT_TRUE(solidLayer2 != nullptr); + auto closedShadeLayer = + Tarcog::ISO15099::Layers::closedShading(solidLayerThickness, solidLayerConductance); + ASSERT_TRUE(closedShadeLayer != nullptr); auto gapThickness = 0.00001; auto gapAirSpeed = 0.0; @@ -54,7 +54,7 @@ class TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed : public testing double windowWidth = 1; double windowHeight = 1; Tarcog::ISO15099::CIGU aIGU(windowWidth, windowHeight); - aIGU.addLayers({solidLayer1, gap, solidLayer2}); + aIGU.addLayers({solidLayer, gap, closedShadeLayer}); ///////////////////////////////////////////////////////// /// System @@ -66,7 +66,7 @@ class TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed : public testing } public: - std::shared_ptr GetSolidLayer1() const + std::shared_ptr GetSolidLayer() const { auto solidLayer = m_TarcogSystem->getSolidLayers()[0]; assert(std::dynamic_pointer_cast(solidLayer) != nullptr); @@ -80,11 +80,12 @@ class TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed : public testing return std::dynamic_pointer_cast(gap); }; - std::shared_ptr GetSolidLayer2() const + std::shared_ptr GetClosedShadeLayer() const { - auto solidLayer = m_TarcogSystem->getSolidLayers()[1]; - assert(std::dynamic_pointer_cast(solidLayer) != nullptr); - return std::dynamic_pointer_cast(solidLayer); + auto closedShadeLayer = m_TarcogSystem->getSolidLayers()[1]; + assert(std::dynamic_pointer_cast(closedShadeLayer) + != nullptr); + return std::dynamic_pointer_cast(closedShadeLayer); }; }; @@ -101,11 +102,11 @@ TEST_F(TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed, GainEnergy) EXPECT_NEAR(0.0, gainEnergy, 1e-4); } -TEST_F(TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed, Solid1Temperatures) +TEST_F(TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed, SolidTemperatures) { - SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Narrow Gap Layer With Zero Air Speed - Solid 1 Temperatures"); + SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Narrow Gap Layer With Zero Air Speed - Solid Temperatures"); - auto aLayer = GetSolidLayer1(); + auto aLayer = GetSolidLayer(); // Airflow iterations are set to 1e-4 and it cannot exceed that precision @@ -135,11 +136,11 @@ TEST_F(TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed, GapTemperature EXPECT_NEAR(264.18283724260709, averageTemperature, 1e-4); } -TEST_F(TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed, Solid2Temperatures) +TEST_F(TestGapLayerSealedForcedVentilationNarrowWithZeroAirSpeed, ClosedShadeTemperatures) { - SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Narrow Gap Layer With Zero Air Speed - Solid 2 Temperatures"); + SCOPED_TRACE("Begin Test: Test Sealed Forced Ventilated Narrow Gap Layer With Zero Air Speed - Closed Shade Temperatures"); - auto aLayer = GetSolidLayer2(); + auto aLayer = GetClosedShadeLayer(); // Airflow iterations are set to 1e-4 and it cannot exceed that precision