diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index bc016ed874..f62be54a99 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -2233,11 +2233,29 @@ OS:Material, \minimum 0 \maximum 1 \default .7 - N7; \field Visible Absorptance + N7, \field Visible Absorptance \type real \minimum 0 \maximum 1 \default .7 + N8, \field Thermal Absorptance Inside Face + \note When blank, this value is equal to the Thermal Absorptance field above. + \note When entered, the Thermal Absorptance field applies to the outside face and this field applies to the inside face. + \type real + \minimum> 0 + \maximum 0.99999 + N9, \field Solar Absorptance Inside Face + \note When blank, this value is equal to the Solar Absorptance field above. + \note When entered, the Solar Absorptance field applies to the outside face and this field applies to the inside face. + \type real + \minimum 0 + \maximum 1 + N10; \field Visible Absorptance Inside Face + \note When blank, this value is equal to the Visible Absorptance field above. + \note When entered, the Visible Absorptance field applies to the outside face and this field applies to the inside face. + \type real + \minimum 0 + \maximum 1 OS:Material:AirGap, \memo Air Space in Opaque Construction @@ -2305,11 +2323,29 @@ OS:Material:NoMass, \minimum 0 \maximum 1 \default .7 - N4; \field Visible Absorptance + N4, \field Visible Absorptance \type real \minimum 0 \maximum 1 \default .7 + N5, \field Thermal Absorptance Inside Face + \note When blank, this value is equal to the Thermal Absorptance field above. + \note When entered, the Thermal Absorptance field applies to the outside face and this field applies to the inside face. + \type real + \minimum> 0 + \maximum 0.99999 + N6, \field Solar Absorptance Inside Face + \note When blank, this value is equal to the Solar Absorptance field above. + \note When entered, the Solar Absorptance field applies to the outside face and this field applies to the inside face. + \type real + \minimum 0 + \maximum 1 + N7; \field Visible Absorptance Inside Face + \note When blank, this value is equal to the Visible Absorptance field above. + \note When entered, the Visible Absorptance field applies to the outside face and this field applies to the inside face. + \type real + \minimum 0 + \maximum 1 OS:Material:RoofVegetation, \memo EcoRoof model, plant layer plus soil layer diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateMasslessOpaqueMaterial.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateMasslessOpaqueMaterial.cpp index fd2c449240..38027d29df 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateMasslessOpaqueMaterial.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateMasslessOpaqueMaterial.cpp @@ -53,6 +53,21 @@ namespace energyplus { idfObject.setDouble(openstudio::Material_NoMassFields::VisibleAbsorptance, *d); } + // Inside-face absorptance fields have no IDD default and inherit the exterior value when blank. + if (!modelObject.isThermalAbsorptanceInsideFaceDefaulted()) { + idfObject.setDouble(openstudio::Material_NoMassFields::ThermalAbsorptanceInsideFace, + modelObject.thermalAbsorptanceInsideFace().get()); + } + + if (!modelObject.isSolarAbsorptanceInsideFaceDefaulted()) { + idfObject.setDouble(openstudio::Material_NoMassFields::SolarAbsorptanceInsideFace, modelObject.solarAbsorptanceInsideFace().get()); + } + + if (!modelObject.isVisibleAbsorptanceInsideFaceDefaulted()) { + idfObject.setDouble(openstudio::Material_NoMassFields::VisibleAbsorptanceInsideFace, + modelObject.visibleAbsorptanceInsideFace().get()); + } + // Call the translation of these objects, which has two advantages: // * will not translate them if they are orphaned (=not referencing a material), and, // * makes the order of these objects in the IDF deterministic diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateStandardOpaqueMaterial.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateStandardOpaqueMaterial.cpp index 5c2c8a445c..18cc349409 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateStandardOpaqueMaterial.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateStandardOpaqueMaterial.cpp @@ -58,6 +58,19 @@ namespace energyplus { idfObject.setDouble(openstudio::MaterialFields::VisibleAbsorptance, *d); } + // Inside-face absorptance fields have no IDD default and inherit the exterior value when blank. + if (!modelObject.isThermalAbsorptanceInsideFaceDefaulted()) { + idfObject.setDouble(openstudio::MaterialFields::ThermalAbsorptanceInsideFace, modelObject.thermalAbsorptanceInsideFace()); + } + + if (!modelObject.isSolarAbsorptanceInsideFaceDefaulted()) { + idfObject.setDouble(openstudio::MaterialFields::SolarAbsorptanceInsideFace, modelObject.solarAbsorptanceInsideFace()); + } + + if (!modelObject.isVisibleAbsorptanceInsideFaceDefaulted()) { + idfObject.setDouble(openstudio::MaterialFields::VisibleAbsorptanceInsideFace, modelObject.visibleAbsorptanceInsideFace()); + } + // Call the translation of these objects, which has two advantages: // * will not translate them if they are orphaned (=not referencing a material), and, // * makes the order of these objects in the IDF deterministic diff --git a/src/energyplus/ReverseTranslator/ReverseTranslateMaterial.cpp b/src/energyplus/ReverseTranslator/ReverseTranslateMaterial.cpp index d2b14f77f9..6f9d6a258f 100644 --- a/src/energyplus/ReverseTranslator/ReverseTranslateMaterial.cpp +++ b/src/energyplus/ReverseTranslator/ReverseTranslateMaterial.cpp @@ -71,6 +71,22 @@ namespace energyplus { mat.setVisibleAbsorptance(od); } + // Inside-face absorptance fields have no IDD default and inherit the exterior value when blank. + od = workspaceObject.getDouble(MaterialFields::ThermalAbsorptanceInsideFace); + if (od) { + mat.setThermalAbsorptanceInsideFace(*od); + } + + od = workspaceObject.getDouble(MaterialFields::SolarAbsorptanceInsideFace); + if (od) { + mat.setSolarAbsorptanceInsideFace(*od); + } + + od = workspaceObject.getDouble(MaterialFields::VisibleAbsorptanceInsideFace); + if (od) { + mat.setVisibleAbsorptanceInsideFace(*od); + } + result = mat; return result; } diff --git a/src/energyplus/ReverseTranslator/ReverseTranslateMaterialNoMass.cpp b/src/energyplus/ReverseTranslator/ReverseTranslateMaterialNoMass.cpp index 706bde71c1..b0e84443c4 100644 --- a/src/energyplus/ReverseTranslator/ReverseTranslateMaterialNoMass.cpp +++ b/src/energyplus/ReverseTranslator/ReverseTranslateMaterialNoMass.cpp @@ -56,6 +56,22 @@ namespace energyplus { MOMat.setVisibleAbsorptance(*d); } + // Inside-face absorptance fields have no IDD default and inherit the exterior value when blank. + d = workspaceObject.getDouble(Material_NoMassFields::ThermalAbsorptanceInsideFace); + if (d) { + MOMat.setThermalAbsorptanceInsideFace(*d); + } + + d = workspaceObject.getDouble(Material_NoMassFields::SolarAbsorptanceInsideFace); + if (d) { + MOMat.setSolarAbsorptanceInsideFace(*d); + } + + d = workspaceObject.getDouble(Material_NoMassFields::VisibleAbsorptanceInsideFace); + if (d) { + MOMat.setVisibleAbsorptanceInsideFace(*d); + } + result = MOMat; return result; } diff --git a/src/energyplus/Test/ForwardTranslator_GTest.cpp b/src/energyplus/Test/ForwardTranslator_GTest.cpp index 719c2c524d..c4f7328c80 100644 --- a/src/energyplus/Test/ForwardTranslator_GTest.cpp +++ b/src/energyplus/Test/ForwardTranslator_GTest.cpp @@ -38,6 +38,7 @@ #include "../../model/CurveQuadratic_Impl.hpp" #include "../../model/CoilCoolingDXSingleSpeed.hpp" #include "../../model/CoilCoolingDXSingleSpeed_Impl.hpp" +#include "../../model/MasslessOpaqueMaterial.hpp" #include "../../model/StandardOpaqueMaterial.hpp" #include "../../model/Construction.hpp" #include "../../model/OutputVariable.hpp" @@ -61,6 +62,8 @@ #include #include #include +#include +#include #include #include @@ -290,6 +293,16 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorTest_TranslateScheduleCompact) { TEST_F(EnergyPlusFixture, ForwardTranslatorTest_TranslateStandardOpaqueMaterial) { openstudio::model::Model model; + openstudio::model::StandardOpaqueMaterial defaultedMaterial(model); + + ForwardTranslator defaultedTrans; + Workspace defaultedWorkspace = defaultedTrans.translateModelObject(defaultedMaterial); + openstudio::IdfObject defaultedMaterialIdf = defaultedWorkspace.getObjectsByType(IddObjectType::Material)[0]; + + EXPECT_FALSE(defaultedMaterialIdf.getDouble(MaterialFields::ThermalAbsorptanceInsideFace)); + EXPECT_FALSE(defaultedMaterialIdf.getDouble(MaterialFields::SolarAbsorptanceInsideFace)); + EXPECT_FALSE(defaultedMaterialIdf.getDouble(MaterialFields::VisibleAbsorptanceInsideFace)); + openstudio::model::StandardOpaqueMaterial mat(model); mat.setName("Test Material"); @@ -301,6 +314,9 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorTest_TranslateStandardOpaqueMaterial) mat.setThermalAbsorptance(0.9); mat.setSolarAbsorptance(0.7); mat.setVisibleAbsorptance(0.7); + mat.setThermalAbsorptanceInsideFace(0.8); + mat.setSolarAbsorptanceInsideFace(0.6); + mat.setVisibleAbsorptanceInsideFace(0.5); ForwardTranslator trans; Workspace workspace = trans.translateModelObject(mat); @@ -309,7 +325,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorTest_TranslateStandardOpaqueMaterial) openstudio::IdfObject matIdf = workspace.getObjectsByType(IddObjectType::Material)[0]; - EXPECT_EQ(unsigned(9), matIdf.numFields()); + EXPECT_EQ(unsigned(12), matIdf.numFields()); EXPECT_EQ("Test Material", *(matIdf.name())); EXPECT_EQ("Rough", *(matIdf.getString(1))); @@ -320,6 +336,35 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorTest_TranslateStandardOpaqueMaterial) EXPECT_EQ(0.9, *(matIdf.getDouble(6))); EXPECT_EQ(0.7, *(matIdf.getDouble(7))); EXPECT_EQ(0.7, *(matIdf.getDouble(8))); + EXPECT_EQ(0.8, *(matIdf.getDouble(MaterialFields::ThermalAbsorptanceInsideFace))); + EXPECT_EQ(0.6, *(matIdf.getDouble(MaterialFields::SolarAbsorptanceInsideFace))); + EXPECT_EQ(0.5, *(matIdf.getDouble(MaterialFields::VisibleAbsorptanceInsideFace))); +} + +TEST_F(EnergyPlusFixture, ForwardTranslatorTest_TranslateMasslessOpaqueMaterialInsideFaceAbsorptance) { + openstudio::model::Model model; + openstudio::model::MasslessOpaqueMaterial defaultedMaterial(model); + + ForwardTranslator trans; + Workspace workspace = trans.translateModelObject(defaultedMaterial); + openstudio::IdfObject defaultedMaterialIdf = workspace.getObjectsByType(IddObjectType::Material_NoMass)[0]; + + EXPECT_FALSE(defaultedMaterialIdf.getDouble(Material_NoMassFields::ThermalAbsorptanceInsideFace)); + EXPECT_FALSE(defaultedMaterialIdf.getDouble(Material_NoMassFields::SolarAbsorptanceInsideFace)); + EXPECT_FALSE(defaultedMaterialIdf.getDouble(Material_NoMassFields::VisibleAbsorptanceInsideFace)); + + openstudio::model::MasslessOpaqueMaterial overriddenMaterial(model); + overriddenMaterial.setThermalAbsorptanceInsideFace(0.8); + overriddenMaterial.setSolarAbsorptanceInsideFace(0.6); + overriddenMaterial.setVisibleAbsorptanceInsideFace(0.5); + + ForwardTranslator overriddenTrans; + Workspace overriddenWorkspace = overriddenTrans.translateModelObject(overriddenMaterial); + openstudio::IdfObject overriddenMaterialIdf = overriddenWorkspace.getObjectsByType(IddObjectType::Material_NoMass)[0]; + + EXPECT_EQ(0.8, overriddenMaterialIdf.getDouble(Material_NoMassFields::ThermalAbsorptanceInsideFace).get()); + EXPECT_EQ(0.6, overriddenMaterialIdf.getDouble(Material_NoMassFields::SolarAbsorptanceInsideFace).get()); + EXPECT_EQ(0.5, overriddenMaterialIdf.getDouble(Material_NoMassFields::VisibleAbsorptanceInsideFace).get()); } TEST_F(EnergyPlusFixture, ForwardTranslatorTest_TranslateConstruction) { diff --git a/src/energyplus/Test/ReverseTranslator_GTest.cpp b/src/energyplus/Test/ReverseTranslator_GTest.cpp index 61fdb47fd7..33c0f79933 100644 --- a/src/energyplus/Test/ReverseTranslator_GTest.cpp +++ b/src/energyplus/Test/ReverseTranslator_GTest.cpp @@ -293,6 +293,9 @@ TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateMasselessOpaqueMaterial idfObject.setString(3, "0.85"); idfObject.setString(4, "0.6"); idfObject.setString(5, "0.6"); + idfObject.setString(6, "0.8"); + idfObject.setString(7, "0.5"); + idfObject.setString(8, "0.4"); WorkspaceObject epMaterial = ws.addObject(idfObject).get(); @@ -308,6 +311,12 @@ TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateMasselessOpaqueMaterial EXPECT_EQ(0.85, mat.thermalAbsorptance().get()); EXPECT_EQ(0.6, mat.solarAbsorptance().get()); EXPECT_EQ(0.6, mat.visibleAbsorptance().get()); + EXPECT_FALSE(mat.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.8, mat.thermalAbsorptanceInsideFace().get()); + EXPECT_FALSE(mat.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.5, mat.solarAbsorptanceInsideFace().get()); + EXPECT_FALSE(mat.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.4, mat.visibleAbsorptanceInsideFace().get()); } TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateStandardOpaqueMaterial) { @@ -323,6 +332,9 @@ TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateStandardOpaqueMaterial) idfObject.setString(6, "0.8"); // Thermal Absorptance idfObject.setString(7, "0.6"); // Solar Absorptance idfObject.setString(8, "0.6"); // Visible Absorptance + idfObject.setString(9, "0.7"); // Thermal Absorptance Inside Face + idfObject.setString(10, "0.5"); // Solar Absorptance Inside Face + idfObject.setString(11, "0.4"); // Visible Absorptance Inside Face openstudio::WorkspaceObject epMaterial = workspace.addObject(idfObject).get(); @@ -333,7 +345,7 @@ TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateStandardOpaqueMaterial) ASSERT_EQ(static_cast(1), model.getConcreteModelObjects().size()); openstudio::model::StandardOpaqueMaterial mat = model.getConcreteModelObjects()[0]; - EXPECT_EQ(unsigned(10), mat.numFields()); + EXPECT_EQ(unsigned(13), mat.numFields()); EXPECT_EQ("Test Material", *(mat.name())); EXPECT_EQ("Smooth", mat.roughness()); @@ -344,6 +356,59 @@ TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateStandardOpaqueMaterial) EXPECT_EQ(0.8, mat.thermalAbsorptance()); EXPECT_EQ(0.6, mat.solarAbsorptance()); EXPECT_EQ(0.6, mat.visibleAbsorptance()); + EXPECT_FALSE(mat.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.7, mat.thermalAbsorptanceInsideFace()); + EXPECT_FALSE(mat.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.5, mat.solarAbsorptanceInsideFace()); + EXPECT_FALSE(mat.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.4, mat.visibleAbsorptanceInsideFace()); +} + +TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateOpaqueMaterialBlankInsideFaceAbsorptance) { + Workspace standardWorkspace(StrictnessLevel::Minimal, IddFileType::EnergyPlus); + IdfObject standardIdfObject(IddObjectType::Material); + standardIdfObject.setString(0, "Standard Material"); + standardIdfObject.setString(1, "Smooth"); + standardIdfObject.setDouble(2, 0.012); + standardIdfObject.setDouble(3, 3.2); + standardIdfObject.setDouble(4, 2.5); + standardIdfObject.setDouble(5, 1400.0); + standardIdfObject.setDouble(6, 0.8); + standardIdfObject.setDouble(7, 0.6); + standardIdfObject.setDouble(8, 0.4); + standardWorkspace.addObject(standardIdfObject); + + ReverseTranslator standardTrans; + Model standardModel = standardTrans.translateWorkspace(standardWorkspace); + auto standardMaterial = standardModel.getConcreteModelObjects()[0]; + + EXPECT_TRUE(standardMaterial.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.8, standardMaterial.thermalAbsorptanceInsideFace()); + EXPECT_TRUE(standardMaterial.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.6, standardMaterial.solarAbsorptanceInsideFace()); + EXPECT_TRUE(standardMaterial.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.4, standardMaterial.visibleAbsorptanceInsideFace()); + + Workspace masslessWorkspace(StrictnessLevel::Minimal, IddFileType::EnergyPlus); + IdfObject masslessIdfObject(IddObjectType::Material_NoMass); + masslessIdfObject.setString(0, "Massless Material"); + masslessIdfObject.setString(1, "Smooth"); + masslessIdfObject.setDouble(2, 3.05); + masslessIdfObject.setDouble(3, 0.8); + masslessIdfObject.setDouble(4, 0.6); + masslessIdfObject.setDouble(5, 0.4); + masslessWorkspace.addObject(masslessIdfObject); + + ReverseTranslator masslessTrans; + Model masslessModel = masslessTrans.translateWorkspace(masslessWorkspace); + auto masslessMaterial = masslessModel.getConcreteModelObjects()[0]; + + EXPECT_TRUE(masslessMaterial.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.8, masslessMaterial.thermalAbsorptanceInsideFace().get()); + EXPECT_TRUE(masslessMaterial.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.6, masslessMaterial.solarAbsorptanceInsideFace().get()); + EXPECT_TRUE(masslessMaterial.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.4, masslessMaterial.visibleAbsorptanceInsideFace().get()); } TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateConstruction) { diff --git a/src/model/MasslessOpaqueMaterial.cpp b/src/model/MasslessOpaqueMaterial.cpp index 4b7da48945..73b3ad650c 100644 --- a/src/model/MasslessOpaqueMaterial.cpp +++ b/src/model/MasslessOpaqueMaterial.cpp @@ -213,6 +213,39 @@ namespace model { return isEmpty(OS_Material_NoMassFields::VisibleAbsorptance); } + double MasslessOpaqueMaterial_Impl::thermalAbsorptanceInsideFace() const { + if (boost::optional value = getDouble(OS_Material_NoMassFields::ThermalAbsorptanceInsideFace)) { + return value.get(); + } + return thermalAbsorptance(); + } + + bool MasslessOpaqueMaterial_Impl::isThermalAbsorptanceInsideFaceDefaulted() const { + return isEmpty(OS_Material_NoMassFields::ThermalAbsorptanceInsideFace); + } + + double MasslessOpaqueMaterial_Impl::solarAbsorptanceInsideFace() const { + if (boost::optional value = getDouble(OS_Material_NoMassFields::SolarAbsorptanceInsideFace)) { + return value.get(); + } + return solarAbsorptance(); + } + + bool MasslessOpaqueMaterial_Impl::isSolarAbsorptanceInsideFaceDefaulted() const { + return isEmpty(OS_Material_NoMassFields::SolarAbsorptanceInsideFace); + } + + double MasslessOpaqueMaterial_Impl::visibleAbsorptanceInsideFace() const { + if (boost::optional value = getDouble(OS_Material_NoMassFields::VisibleAbsorptanceInsideFace)) { + return value.get(); + } + return visibleAbsorptance(); + } + + bool MasslessOpaqueMaterial_Impl::isVisibleAbsorptanceInsideFaceDefaulted() const { + return isEmpty(OS_Material_NoMassFields::VisibleAbsorptanceInsideFace); + } + bool MasslessOpaqueMaterial_Impl::setRoughness(const std::string& roughness) { bool result = setString(OS_Material_NoMassFields::Roughness, roughness); return result; @@ -253,6 +286,33 @@ namespace model { OS_ASSERT(result); } + bool MasslessOpaqueMaterial_Impl::setThermalAbsorptanceInsideFace(double thermalAbsorptanceInsideFace) { + return setDouble(OS_Material_NoMassFields::ThermalAbsorptanceInsideFace, thermalAbsorptanceInsideFace); + } + + void MasslessOpaqueMaterial_Impl::resetThermalAbsorptanceInsideFace() { + bool result = setString(OS_Material_NoMassFields::ThermalAbsorptanceInsideFace, ""); + OS_ASSERT(result); + } + + bool MasslessOpaqueMaterial_Impl::setSolarAbsorptanceInsideFace(double solarAbsorptanceInsideFace) { + return setDouble(OS_Material_NoMassFields::SolarAbsorptanceInsideFace, solarAbsorptanceInsideFace); + } + + void MasslessOpaqueMaterial_Impl::resetSolarAbsorptanceInsideFace() { + bool result = setString(OS_Material_NoMassFields::SolarAbsorptanceInsideFace, ""); + OS_ASSERT(result); + } + + bool MasslessOpaqueMaterial_Impl::setVisibleAbsorptanceInsideFace(double visibleAbsorptanceInsideFace) { + return setDouble(OS_Material_NoMassFields::VisibleAbsorptanceInsideFace, visibleAbsorptanceInsideFace); + } + + void MasslessOpaqueMaterial_Impl::resetVisibleAbsorptanceInsideFace() { + bool result = setString(OS_Material_NoMassFields::VisibleAbsorptanceInsideFace, ""); + OS_ASSERT(result); + } + std::vector MasslessOpaqueMaterial_Impl::roughnessValues() const { return MasslessOpaqueMaterial::roughnessValues(); } @@ -421,6 +481,30 @@ namespace model { return result; } + boost::optional MasslessOpaqueMaterial::thermalAbsorptanceInsideFace() const { + return getImpl()->thermalAbsorptanceInsideFace(); + } + + bool MasslessOpaqueMaterial::isThermalAbsorptanceInsideFaceDefaulted() const { + return getImpl()->isThermalAbsorptanceInsideFaceDefaulted(); + } + + boost::optional MasslessOpaqueMaterial::solarAbsorptanceInsideFace() const { + return getImpl()->solarAbsorptanceInsideFace(); + } + + bool MasslessOpaqueMaterial::isSolarAbsorptanceInsideFaceDefaulted() const { + return getImpl()->isSolarAbsorptanceInsideFaceDefaulted(); + } + + boost::optional MasslessOpaqueMaterial::visibleAbsorptanceInsideFace() const { + return getImpl()->visibleAbsorptanceInsideFace(); + } + + bool MasslessOpaqueMaterial::isVisibleAbsorptanceInsideFaceDefaulted() const { + return getImpl()->isVisibleAbsorptanceInsideFaceDefaulted(); + } + // cppcheck-suppress [duplInheritedMember] for documentation purposes double MasslessOpaqueMaterial::thermalResistance() const { return getImpl()->thermalResistance(); @@ -472,6 +556,30 @@ namespace model { getImpl()->resetVisibleAbsorptance(); } + bool MasslessOpaqueMaterial::setThermalAbsorptanceInsideFace(double thermalAbsorptanceInsideFace) { + return getImpl()->setThermalAbsorptanceInsideFace(thermalAbsorptanceInsideFace); + } + + void MasslessOpaqueMaterial::resetThermalAbsorptanceInsideFace() { + getImpl()->resetThermalAbsorptanceInsideFace(); + } + + bool MasslessOpaqueMaterial::setSolarAbsorptanceInsideFace(double solarAbsorptanceInsideFace) { + return getImpl()->setSolarAbsorptanceInsideFace(solarAbsorptanceInsideFace); + } + + void MasslessOpaqueMaterial::resetSolarAbsorptanceInsideFace() { + getImpl()->resetSolarAbsorptanceInsideFace(); + } + + bool MasslessOpaqueMaterial::setVisibleAbsorptanceInsideFace(double visibleAbsorptanceInsideFace) { + return getImpl()->setVisibleAbsorptanceInsideFace(visibleAbsorptanceInsideFace); + } + + void MasslessOpaqueMaterial::resetVisibleAbsorptanceInsideFace() { + getImpl()->resetVisibleAbsorptanceInsideFace(); + } + boost::optional MasslessOpaqueMaterial::createMaterialPropertyMoisturePenetrationDepthSettings( double waterVaporDiffusionResistanceFactor, double moistureEquationCoefficientA, double moistureEquationCoefficientB, double moistureEquationCoefficientC, double moistureEquationCoefficientD, double coatingLayerThickness, diff --git a/src/model/MasslessOpaqueMaterial.hpp b/src/model/MasslessOpaqueMaterial.hpp index cb0879fc97..344909cbfd 100644 --- a/src/model/MasslessOpaqueMaterial.hpp +++ b/src/model/MasslessOpaqueMaterial.hpp @@ -71,6 +71,18 @@ namespace model { bool isVisibleAbsorptanceDefaulted() const; + boost::optional thermalAbsorptanceInsideFace() const; + + bool isThermalAbsorptanceInsideFaceDefaulted() const; + + boost::optional solarAbsorptanceInsideFace() const; + + bool isSolarAbsorptanceInsideFaceDefaulted() const; + + boost::optional visibleAbsorptanceInsideFace() const; + + bool isVisibleAbsorptanceInsideFaceDefaulted() const; + //@} /** @name Setters */ //@{ @@ -91,6 +103,18 @@ namespace model { void resetVisibleAbsorptance(); + bool setThermalAbsorptanceInsideFace(double thermalAbsorptanceInsideFace); + + void resetThermalAbsorptanceInsideFace(); + + bool setSolarAbsorptanceInsideFace(double solarAbsorptanceInsideFace); + + void resetSolarAbsorptanceInsideFace(); + + bool setVisibleAbsorptanceInsideFace(double visibleAbsorptanceInsideFace); + + void resetVisibleAbsorptanceInsideFace(); + // if material property moisture penetration depth settings already exists, do nothing and return nil; creates the material property moisture penetration depth settings if it does not already exist and return it boost::optional createMaterialPropertyMoisturePenetrationDepthSettings(double waterVaporDiffusionResistanceFactor, double moistureEquationCoefficientA, diff --git a/src/model/MasslessOpaqueMaterial_Impl.hpp b/src/model/MasslessOpaqueMaterial_Impl.hpp index 3baa94899b..c7b55bded9 100644 --- a/src/model/MasslessOpaqueMaterial_Impl.hpp +++ b/src/model/MasslessOpaqueMaterial_Impl.hpp @@ -78,6 +78,18 @@ namespace model { bool isVisibleAbsorptanceDefaulted() const; + double thermalAbsorptanceInsideFace() const; + + bool isThermalAbsorptanceInsideFaceDefaulted() const; + + double solarAbsorptanceInsideFace() const; + + bool isSolarAbsorptanceInsideFaceDefaulted() const; + + double visibleAbsorptanceInsideFace() const; + + bool isVisibleAbsorptanceInsideFaceDefaulted() const; + //@} /** @name Setters */ //@{ @@ -123,6 +135,18 @@ namespace model { void resetVisibleAbsorptance(); + bool setThermalAbsorptanceInsideFace(double thermalAbsorptanceInsideFace); + + void resetThermalAbsorptanceInsideFace(); + + bool setSolarAbsorptanceInsideFace(double solarAbsorptanceInsideFace); + + void resetSolarAbsorptanceInsideFace(); + + bool setVisibleAbsorptanceInsideFace(double visibleAbsorptanceInsideFace); + + void resetVisibleAbsorptanceInsideFace(); + // if material property moisture penetration depth settings already exists, do nothing and return nil; creates the material property moisture penetration depth settings if it does not already exist and return it; boost::optional createMaterialPropertyMoisturePenetrationDepthSettings(double waterVaporDiffusionResistanceFactor, double moistureEquationCoefficientA, diff --git a/src/model/StandardOpaqueMaterial.cpp b/src/model/StandardOpaqueMaterial.cpp index 1af1628b7d..2620e0991b 100644 --- a/src/model/StandardOpaqueMaterial.cpp +++ b/src/model/StandardOpaqueMaterial.cpp @@ -191,6 +191,39 @@ namespace model { return isEmpty(OS_MaterialFields::VisibleAbsorptance); } + double StandardOpaqueMaterial_Impl::thermalAbsorptanceInsideFace() const { + if (boost::optional value = getDouble(OS_MaterialFields::ThermalAbsorptanceInsideFace)) { + return value.get(); + } + return thermalAbsorptance(); + } + + bool StandardOpaqueMaterial_Impl::isThermalAbsorptanceInsideFaceDefaulted() const { + return isEmpty(OS_MaterialFields::ThermalAbsorptanceInsideFace); + } + + double StandardOpaqueMaterial_Impl::solarAbsorptanceInsideFace() const { + if (boost::optional value = getDouble(OS_MaterialFields::SolarAbsorptanceInsideFace)) { + return value.get(); + } + return solarAbsorptance(); + } + + bool StandardOpaqueMaterial_Impl::isSolarAbsorptanceInsideFaceDefaulted() const { + return isEmpty(OS_MaterialFields::SolarAbsorptanceInsideFace); + } + + double StandardOpaqueMaterial_Impl::visibleAbsorptanceInsideFace() const { + if (boost::optional value = getDouble(OS_MaterialFields::VisibleAbsorptanceInsideFace)) { + return value.get(); + } + return visibleAbsorptance(); + } + + bool StandardOpaqueMaterial_Impl::isVisibleAbsorptanceInsideFaceDefaulted() const { + return isEmpty(OS_MaterialFields::VisibleAbsorptanceInsideFace); + } + bool StandardOpaqueMaterial_Impl::setRoughness(const std::string& roughness) { bool result = setString(OS_MaterialFields::Roughness, roughness); return result; @@ -301,6 +334,33 @@ namespace model { OS_ASSERT(result); } + bool StandardOpaqueMaterial_Impl::setThermalAbsorptanceInsideFace(double thermalAbsorptanceInsideFace) { + return setDouble(OS_MaterialFields::ThermalAbsorptanceInsideFace, thermalAbsorptanceInsideFace); + } + + void StandardOpaqueMaterial_Impl::resetThermalAbsorptanceInsideFace() { + bool result = setString(OS_MaterialFields::ThermalAbsorptanceInsideFace, ""); + OS_ASSERT(result); + } + + bool StandardOpaqueMaterial_Impl::setSolarAbsorptanceInsideFace(double solarAbsorptanceInsideFace) { + return setDouble(OS_MaterialFields::SolarAbsorptanceInsideFace, solarAbsorptanceInsideFace); + } + + void StandardOpaqueMaterial_Impl::resetSolarAbsorptanceInsideFace() { + bool result = setString(OS_MaterialFields::SolarAbsorptanceInsideFace, ""); + OS_ASSERT(result); + } + + bool StandardOpaqueMaterial_Impl::setVisibleAbsorptanceInsideFace(double visibleAbsorptanceInsideFace) { + return setDouble(OS_MaterialFields::VisibleAbsorptanceInsideFace, visibleAbsorptanceInsideFace); + } + + void StandardOpaqueMaterial_Impl::resetVisibleAbsorptanceInsideFace() { + bool result = setString(OS_MaterialFields::VisibleAbsorptanceInsideFace, ""); + OS_ASSERT(result); + } + std::vector StandardOpaqueMaterial_Impl::roughnessValues() const { return StandardOpaqueMaterial::roughnessValues(); } @@ -603,6 +663,30 @@ namespace model { return getImpl()->isVisibleAbsorptanceDefaulted(); } + double StandardOpaqueMaterial::thermalAbsorptanceInsideFace() const { + return getImpl()->thermalAbsorptanceInsideFace(); + } + + bool StandardOpaqueMaterial::isThermalAbsorptanceInsideFaceDefaulted() const { + return getImpl()->isThermalAbsorptanceInsideFaceDefaulted(); + } + + double StandardOpaqueMaterial::solarAbsorptanceInsideFace() const { + return getImpl()->solarAbsorptanceInsideFace(); + } + + bool StandardOpaqueMaterial::isSolarAbsorptanceInsideFaceDefaulted() const { + return getImpl()->isSolarAbsorptanceInsideFaceDefaulted(); + } + + double StandardOpaqueMaterial::visibleAbsorptanceInsideFace() const { + return getImpl()->visibleAbsorptanceInsideFace(); + } + + bool StandardOpaqueMaterial::isVisibleAbsorptanceInsideFaceDefaulted() const { + return getImpl()->isVisibleAbsorptanceInsideFaceDefaulted(); + } + bool StandardOpaqueMaterial::setRoughness(const std::string& roughness) { return getImpl()->setRoughness(roughness); } @@ -649,6 +733,30 @@ namespace model { getImpl()->resetVisibleAbsorptance(); } + bool StandardOpaqueMaterial::setThermalAbsorptanceInsideFace(double thermalAbsorptanceInsideFace) { + return getImpl()->setThermalAbsorptanceInsideFace(thermalAbsorptanceInsideFace); + } + + void StandardOpaqueMaterial::resetThermalAbsorptanceInsideFace() { + getImpl()->resetThermalAbsorptanceInsideFace(); + } + + bool StandardOpaqueMaterial::setSolarAbsorptanceInsideFace(double solarAbsorptanceInsideFace) { + return getImpl()->setSolarAbsorptanceInsideFace(solarAbsorptanceInsideFace); + } + + void StandardOpaqueMaterial::resetSolarAbsorptanceInsideFace() { + getImpl()->resetSolarAbsorptanceInsideFace(); + } + + bool StandardOpaqueMaterial::setVisibleAbsorptanceInsideFace(double visibleAbsorptanceInsideFace) { + return getImpl()->setVisibleAbsorptanceInsideFace(visibleAbsorptanceInsideFace); + } + + void StandardOpaqueMaterial::resetVisibleAbsorptanceInsideFace() { + getImpl()->resetVisibleAbsorptanceInsideFace(); + } + boost::optional StandardOpaqueMaterial::createMaterialPropertyMoisturePenetrationDepthSettings( double waterVaporDiffusionResistanceFactor, double moistureEquationCoefficientA, double moistureEquationCoefficientB, double moistureEquationCoefficientC, double moistureEquationCoefficientD, double coatingLayerThickness, diff --git a/src/model/StandardOpaqueMaterial.hpp b/src/model/StandardOpaqueMaterial.hpp index 62ad3fa3c8..33771bcd18 100644 --- a/src/model/StandardOpaqueMaterial.hpp +++ b/src/model/StandardOpaqueMaterial.hpp @@ -99,6 +99,18 @@ namespace model { bool isVisibleAbsorptanceDefaulted() const; + double thermalAbsorptanceInsideFace() const; + + bool isThermalAbsorptanceInsideFaceDefaulted() const; + + double solarAbsorptanceInsideFace() const; + + bool isSolarAbsorptanceInsideFaceDefaulted() const; + + double visibleAbsorptanceInsideFace() const; + + bool isVisibleAbsorptanceInsideFaceDefaulted() const; + //@} /** @name Setters */ //@{ @@ -155,6 +167,18 @@ namespace model { void resetVisibleAbsorptance(); + bool setThermalAbsorptanceInsideFace(double thermalAbsorptanceInsideFace); + + void resetThermalAbsorptanceInsideFace(); + + bool setSolarAbsorptanceInsideFace(double solarAbsorptanceInsideFace); + + void resetSolarAbsorptanceInsideFace(); + + bool setVisibleAbsorptanceInsideFace(double visibleAbsorptanceInsideFace); + + void resetVisibleAbsorptanceInsideFace(); + // if material property moisture penetration depth settings already exists, do nothing and return nil; creates the material property moisture penetration depth settings if it does not already exist and return it boost::optional createMaterialPropertyMoisturePenetrationDepthSettings(double waterVaporDiffusionResistanceFactor, double moistureEquationCoefficientA, diff --git a/src/model/StandardOpaqueMaterial_Impl.hpp b/src/model/StandardOpaqueMaterial_Impl.hpp index 33773cfce0..8e6120c779 100644 --- a/src/model/StandardOpaqueMaterial_Impl.hpp +++ b/src/model/StandardOpaqueMaterial_Impl.hpp @@ -93,6 +93,18 @@ namespace model { virtual bool isVisibleAbsorptanceDefaulted() const; + virtual double thermalAbsorptanceInsideFace() const; + + virtual bool isThermalAbsorptanceInsideFaceDefaulted() const; + + virtual double solarAbsorptanceInsideFace() const; + + virtual bool isSolarAbsorptanceInsideFaceDefaulted() const; + + virtual double visibleAbsorptanceInsideFace() const; + + virtual bool isVisibleAbsorptanceInsideFaceDefaulted() const; + virtual std::vector emsActuatorNames() const override; virtual std::vector emsInternalVariableNames() const override; @@ -147,6 +159,18 @@ namespace model { virtual void resetVisibleAbsorptance(); + virtual bool setThermalAbsorptanceInsideFace(double thermalAbsorptanceInsideFace); + + virtual void resetThermalAbsorptanceInsideFace(); + + virtual bool setSolarAbsorptanceInsideFace(double solarAbsorptanceInsideFace); + + virtual void resetSolarAbsorptanceInsideFace(); + + virtual bool setVisibleAbsorptanceInsideFace(double visibleAbsorptanceInsideFace); + + virtual void resetVisibleAbsorptanceInsideFace(); + // if material property moisture penetration depth settings already exists, do nothing and return nil; creates the material property moisture penetration depth settings if it does not already exist and return it; boost::optional createMaterialPropertyMoisturePenetrationDepthSettings(double waterVaporDiffusionResistanceFactor, double moistureEquationCoefficientA, diff --git a/src/model/test/MasslessOpaqueMaterial_GTest.cpp b/src/model/test/MasslessOpaqueMaterial_GTest.cpp index f8a84850df..285f111c2c 100644 --- a/src/model/test/MasslessOpaqueMaterial_GTest.cpp +++ b/src/model/test/MasslessOpaqueMaterial_GTest.cpp @@ -77,6 +77,33 @@ TEST_F(ModelFixture, MasslessOpaqueMaterial_GettersSetters) { EXPECT_EQ(0.36, mat.visibleAbsorptance().get()); mat.resetVisibleAbsorptance(); EXPECT_EQ(.7, mat.visibleAbsorptance().get()); + + EXPECT_TRUE(mat.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(mat.thermalAbsorptance().get(), mat.thermalAbsorptanceInsideFace().get()); + EXPECT_TRUE(mat.setThermalAbsorptanceInsideFace(0.25)); + EXPECT_FALSE(mat.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.25, mat.thermalAbsorptanceInsideFace().get()); + mat.resetThermalAbsorptanceInsideFace(); + EXPECT_TRUE(mat.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(mat.thermalAbsorptance().get(), mat.thermalAbsorptanceInsideFace().get()); + + EXPECT_TRUE(mat.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(mat.solarAbsorptance().get(), mat.solarAbsorptanceInsideFace().get()); + EXPECT_TRUE(mat.setSolarAbsorptanceInsideFace(0.35)); + EXPECT_FALSE(mat.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.35, mat.solarAbsorptanceInsideFace().get()); + mat.resetSolarAbsorptanceInsideFace(); + EXPECT_TRUE(mat.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(mat.solarAbsorptance().get(), mat.solarAbsorptanceInsideFace().get()); + + EXPECT_TRUE(mat.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(mat.visibleAbsorptance().get(), mat.visibleAbsorptanceInsideFace().get()); + EXPECT_TRUE(mat.setVisibleAbsorptanceInsideFace(0.45)); + EXPECT_FALSE(mat.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.45, mat.visibleAbsorptanceInsideFace().get()); + mat.resetVisibleAbsorptanceInsideFace(); + EXPECT_TRUE(mat.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(mat.visibleAbsorptance().get(), mat.visibleAbsorptanceInsideFace().get()); } TEST_F(ModelFixture, MasslessOpaqueMaterial_StandardsInformation) { diff --git a/src/model/test/StandardOpaqueMaterial_GTest.cpp b/src/model/test/StandardOpaqueMaterial_GTest.cpp index 72a826efb8..a92adba6c4 100644 --- a/src/model/test/StandardOpaqueMaterial_GTest.cpp +++ b/src/model/test/StandardOpaqueMaterial_GTest.cpp @@ -250,6 +250,33 @@ TEST_F(ModelFixture, StandardOpaqueMaterial_SetGetFields) { material.resetVisibleAbsorptance(); EXPECT_TRUE(material.isVisibleAbsorptanceDefaulted()); + + EXPECT_TRUE(material.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(material.thermalAbsorptance(), material.thermalAbsorptanceInsideFace()); + EXPECT_TRUE(material.setThermalAbsorptanceInsideFace(0.3)); + EXPECT_FALSE(material.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.3, material.thermalAbsorptanceInsideFace()); + material.resetThermalAbsorptanceInsideFace(); + EXPECT_TRUE(material.isThermalAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(material.thermalAbsorptance(), material.thermalAbsorptanceInsideFace()); + + EXPECT_TRUE(material.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(material.solarAbsorptance(), material.solarAbsorptanceInsideFace()); + EXPECT_TRUE(material.setSolarAbsorptanceInsideFace(0.4)); + EXPECT_FALSE(material.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.4, material.solarAbsorptanceInsideFace()); + material.resetSolarAbsorptanceInsideFace(); + EXPECT_TRUE(material.isSolarAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(material.solarAbsorptance(), material.solarAbsorptanceInsideFace()); + + EXPECT_TRUE(material.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(material.visibleAbsorptance(), material.visibleAbsorptanceInsideFace()); + EXPECT_TRUE(material.setVisibleAbsorptanceInsideFace(0.5)); + EXPECT_FALSE(material.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(0.5, material.visibleAbsorptanceInsideFace()); + material.resetVisibleAbsorptanceInsideFace(); + EXPECT_TRUE(material.isVisibleAbsorptanceInsideFaceDefaulted()); + EXPECT_EQ(material.visibleAbsorptance(), material.visibleAbsorptanceInsideFace()); } TEST_F(ModelFixture, StandardOpaqueMaterial_Clone) {