#5145 - HeatExchangerAirToAirSensibleAndLatent normalization divisor error

src/model/HeatExchangerAirToAirSensibleAndLatent.cpp

@@ -35,6 +35,8 @@
 // Remove when deprecated methods are removed
 #include "../utilities/core/DeprecatedHelpers.hpp"
 
+#include <limits>
+
 namespace openstudio {
 
 namespace model {
@@ -1026,8 +1028,13 @@ namespace model {
       return setCurveAt75(*curve_, sensibleEffectivenessat75HeatingAirFlow);
     }
 
-    auto tableLookup = makeTable(sensibleEffectivenessat75HeatingAirFlow, sensibleEffectivenessat100HeatingAirFlow(), model(),
-                                 fmt::format("{}_SensHeatEff", nameString()));
+    const auto val100 = sensibleEffectivenessat100HeatingAirFlow();
+    if (std::abs(val100) < std::numeric_limits<double>::min()) {
+      LOG_AND_THROW("Unable to set " << briefDescription()
+                                     << "'s Sensible Effectiveness at 75 Heating Air Flow because the value at 100 is zero and would lead to a "
+                                        "Normalization divisor equal to zero.");
+    }
+    auto tableLookup = makeTable(sensibleEffectivenessat75HeatingAirFlow, val100, model(), fmt::format("{}_SensHeatEff", nameString()));
     return setSensibleEffectivenessofHeatingAirFlowCurve(tableLookup);
   }
 
@@ -1038,8 +1045,13 @@ namespace model {
       return setCurveAt75(*curve_, latentEffectivenessat75HeatingAirFlow);
     }
 
-    auto tableLookup =
-      makeTable(latentEffectivenessat75HeatingAirFlow, latentEffectivenessat100HeatingAirFlow(), model(), fmt::format("{}_LatHeatEff", nameString()));
+    const auto val100 = latentEffectivenessat100HeatingAirFlow();
+    if (std::abs(val100) < std::numeric_limits<double>::min()) {
+      LOG_AND_THROW("Unable to set " << briefDescription()
+                                     << "'s Latent Effectiveness at 75 Heating Air Flow because the value at 100 is zero and would lead to a "
+                                        "Normalization divisor equal to zero.");
+    }
+    auto tableLookup = makeTable(latentEffectivenessat75HeatingAirFlow, val100, model(), fmt::format("{}_LatHeatEff", nameString()));
     return setLatentEffectivenessofHeatingAirFlowCurve(tableLookup);
   }
 
@@ -1050,8 +1062,13 @@ namespace model {
       return setCurveAt75(*curve_, sensibleEffectivenessat75CoolingAirFlow);
     }
 
-    auto tableLookup = makeTable(sensibleEffectivenessat75CoolingAirFlow, sensibleEffectivenessat100CoolingAirFlow(), model(),
-                                 fmt::format("{}_SensCoolEff", nameString()));
+    const auto val100 = sensibleEffectivenessat100CoolingAirFlow();
+    if (std::abs(val100) < std::numeric_limits<double>::min()) {
+      LOG_AND_THROW("Unable to set " << briefDescription()
+                                     << "'s Sensible Effectiveness at 75 Cooling Air Flow because the value at 100 is zero and would lead to a "
+                                        "Normalization divisor equal to zero.");
+    }
+    auto tableLookup = makeTable(sensibleEffectivenessat75CoolingAirFlow, val100, model(), fmt::format("{}_SensCoolEff", nameString()));
     return setSensibleEffectivenessofCoolingAirFlowCurve(tableLookup);
   }
 
@@ -1062,8 +1079,13 @@ namespace model {
       return setCurveAt75(*curve_, latentEffectivenessat75CoolingAirFlow);
     }
 
-    auto tableLookup =
-      makeTable(latentEffectivenessat75CoolingAirFlow, latentEffectivenessat100CoolingAirFlow(), model(), fmt::format("{}_LatCoolEff", nameString()));
+    const auto val100 = latentEffectivenessat100CoolingAirFlow();
+    if (std::abs(val100) < std::numeric_limits<double>::min()) {
+      LOG_AND_THROW("Unable to set " << briefDescription()
+                                     << "'s Latent Effectiveness at 75 Cooling Air Flow because the value at 100 is zero and would lead to a "
+                                        "Normalization divisor equal to zero.");
+    }
+    auto tableLookup = makeTable(latentEffectivenessat75CoolingAirFlow, val100, model(), fmt::format("{}_LatCoolEff", nameString()));
     return setLatentEffectivenessofCoolingAirFlowCurve(tableLookup);
   }
 

src/model/TableLookup.cpp

@@ -26,6 +26,7 @@
 
 #include <algorithm>
 #include <iomanip>
+#include <limits>
 
 namespace openstudio {
 namespace model {
@@ -165,8 +166,13 @@ namespace model {
       return result;
     }
 
-    bool TableLookup_Impl::setNormalizationDivisor(double normalizationDivisior) {
-      bool result = setDouble(OS_Table_LookupFields::NormalizationDivisor, normalizationDivisior);
+    bool TableLookup_Impl::setNormalizationDivisor(double normalizationDivisor) {
+      if (std::abs(normalizationDivisor) < std::numeric_limits<double>::min()) {
+        LOG(Warn, "Unable to set " << briefDescription() << "'s Normalization divisor to zero.");
+        return false;
+      }
+
+      bool result = setDouble(OS_Table_LookupFields::NormalizationDivisor, normalizationDivisor);
       return result;
     }
 
@@ -374,8 +380,8 @@ namespace model {
     return getImpl<detail::TableLookup_Impl>()->setNormalizationMethod(normalizationMethod);
   }
 
-  bool TableLookup::setNormalizationDivisor(double normalizationDivisior) {
-    return getImpl<detail::TableLookup_Impl>()->setNormalizationDivisor(normalizationDivisior);
+  bool TableLookup::setNormalizationDivisor(double normalizationDivisor) {
+    return getImpl<detail::TableLookup_Impl>()->setNormalizationDivisor(normalizationDivisor);
   }
 
   bool TableLookup::setMinimumOutput(double minimumOutput) {

src/model/TableLookup.hpp

@@ -69,7 +69,7 @@ namespace model {
 
     bool setNormalizationMethod(const std::string& normalizationMethod);
 
-    bool setNormalizationDivisor(double normalizationDivisior);
+    bool setNormalizationDivisor(double normalizationDivisor);
 
     bool setMinimumOutput(double minimumOutput);
     void resetMinimumOutput();

src/model/TableLookup_Impl.hpp

@@ -72,7 +72,7 @@ namespace model {
 
       bool setNormalizationMethod(const std::string& normalizationMethod);
 
-      bool setNormalizationDivisor(double normalizationDivisior);
+      bool setNormalizationDivisor(double normalizationDivisor);
 
       bool setMinimumOutput(double minimumOutput);
       void resetMinimumOutput();

src/model/test/HeatExchangerAirToAirSensibleAndLatent_GTest.cpp

@@ -401,6 +401,26 @@ TEST_F(ModelFixture, HeatExchangerAirToAirSensibleAndLatent_Deprecated75Effectiv
     EXPECT_TRUE(hx.setLatentEffectivenessat75CoolingAirFlow(val2));
     EXPECT_DOUBLE_EQ(val2, hx.latentEffectivenessat75CoolingAirFlow());
   }
+
+  // Ensure we protect users against dumb issues that lead to a normalization divisor of zero
+  {
+    // Ensure no curves assigned for now
+    hx.resetSensibleEffectivenessofHeatingAirFlowCurve();
+    hx.resetLatentEffectivenessofHeatingAirFlowCurve();
+    hx.resetSensibleEffectivenessofCoolingAirFlowCurve();
+    hx.resetLatentEffectivenessofCoolingAirFlowCurve();
+
+    // IMHO this doesn't make sense (IDD should be `\minimum> 0.0`), but the E+ IDD and OS IDD have always allowed it, so leaving it untouched
+    EXPECT_TRUE(hx.setSensibleEffectivenessat100HeatingAirFlow(0.0));
+    EXPECT_TRUE(hx.setLatentEffectivenessat100HeatingAirFlow(0.0));
+    EXPECT_TRUE(hx.setSensibleEffectivenessat100CoolingAirFlow(0.0));
+    EXPECT_TRUE(hx.setLatentEffectivenessat100CoolingAirFlow(0.0));
+
+    EXPECT_ANY_THROW(hx.setSensibleEffectivenessat75HeatingAirFlow(0.5));
+    EXPECT_ANY_THROW(hx.setLatentEffectivenessat75HeatingAirFlow(0.5));
+    EXPECT_ANY_THROW(hx.setSensibleEffectivenessat75CoolingAirFlow(0.5));
+    EXPECT_ANY_THROW(hx.setLatentEffectivenessat75CoolingAirFlow(0.5));
+  }
 }
 
 TEST_F(ModelFixture, HeatExchangerAirToAirSensibleAndLatent_assignHistoricalEffectivenessCurves) {

src/model/test/TableLookup_GTest.cpp

@@ -51,6 +51,10 @@ TEST_F(ModelFixture, TableLookup_GettersSetters) {
   EXPECT_TRUE(tableLookup.setNormalizationDivisor(0.5));
   EXPECT_EQ(0.5, tableLookup.normalizationDivisor());
 
+  // #5145 - We reject 0 as a normalization divisor
+  EXPECT_FALSE(tableLookup.setNormalizationDivisor(0.0));
+  EXPECT_EQ(0.5, tableLookup.normalizationDivisor());
+
   // Minimum Output: Optional Double
   EXPECT_TRUE(tableLookup.setMinimumOutput(0.6));
   ASSERT_TRUE(tableLookup.minimumOutput());