V26.2.0-IOFreeze: new Absorptance Inside Face fields

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

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

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

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;
   }

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;
   }

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 <utilities/idd/Schedule_Compact_FieldEnums.hxx>
 #include <utilities/idd/ZoneCapacitanceMultiplier_ResearchSpecial_FieldEnums.hxx>
 #include <utilities/idd/Output_Variable_FieldEnums.hxx>
+#include <utilities/idd/Material_FieldEnums.hxx>
+#include <utilities/idd/Material_NoMass_FieldEnums.hxx>
 #include <utilities/idd/IddEnums.hxx>
 #include <utilities/idd/IddFactory.hxx>
 
@@ -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) {

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<unsigned>(1), model.getConcreteModelObjects<openstudio::model::StandardOpaqueMaterial>().size());
   openstudio::model::StandardOpaqueMaterial mat = model.getConcreteModelObjects<openstudio::model::StandardOpaqueMaterial>()[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<StandardOpaqueMaterial>()[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<MasslessOpaqueMaterial>()[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) {