From 9405db6784f224bd7cf81ffbca8e4ddcdc0ed31f Mon Sep 17 00:00:00 2001 From: Julien Marrec Date: Thu, 1 Jun 2023 13:17:39 +0200 Subject: [PATCH 01/15] Cleanup the DuringCooling API. One break, the return of supplyAirFlowRateMethodDuringCooling, which can be avoided (keep returning optional even if always initialized) --- ...rwardTranslateAirLoopHVACUnitarySystem.cpp | 59 +++-- src/model/AirLoopHVACUnitarySystem.cpp | 235 ++++++++++-------- src/model/AirLoopHVACUnitarySystem.hpp | 22 +- src/model/AirLoopHVACUnitarySystem_Impl.hpp | 18 +- .../test/AirLoopHVACUnitarySystem_GTest.cpp | 107 ++++++-- 5 files changed, 260 insertions(+), 181 deletions(-) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp index e42dca97a7..ab376507a2 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp @@ -237,6 +237,34 @@ namespace energyplus { unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingCoilObjectType, _coolingCoil->iddObject().name()); unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingCoilName, _coolingCoil->name().get()); } + + // Supply Air Flow Rate Method During Cooling Operation + unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRateMethod, + modelObject.supplyAirFlowRateMethodDuringCoolingOperation()); + + // Supply Air Flow Rate During Cooling Operation + if (modelObject.isSupplyAirFlowRateDuringCoolingOperationAutosized()) { + unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRate, "Autosize"); + } else if (auto val_ = modelObject.supplyAirFlowRateDuringCoolingOperation()) { + unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRate, val_.get()); + } + + // Supply Air Flow Rate Per Floor Area During Cooling Operation + if (auto val_ = modelObject.supplyAirFlowRatePerFloorAreaDuringCoolingOperation()) { + unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRatePerFloorArea, val_.get()); + } + + // Fraction of Autosized Design Cooling Supply Air Flow Rate + if (auto val_ = modelObject.fractionofAutosizedDesignCoolingSupplyAirFlowRate()) { + unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingFractionofAutosizedCoolingSupplyAirFlowRate, val_.get()); + } + + // Design Supply Air Flow Rate Per Unit of Capacity During Cooling Operation + if (auto val_ = modelObject.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()) { + unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRatePerUnitofCapacity, val_.get()); + } + } else { + unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRateMethod, "None"); } // Use DOAS DX Cooling Coil @@ -272,37 +300,6 @@ namespace energyplus { } } - // Supply Air Flow Rate Method During Cooling Operation - s = modelObject.supplyAirFlowRateMethodDuringCoolingOperation(); - if (s) { - unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRateMethod, s.get()); - } - - // Supply Air Flow Rate During Cooling Operation - if (modelObject.isSupplyAirFlowRateDuringCoolingOperationAutosized()) { - unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRate, "Autosize"); - } else if ((d = modelObject.supplyAirFlowRateDuringCoolingOperation())) { - unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRate, d.get()); - } - - // Supply Air Flow Rate Per Floor Area During Cooling Operation - d = modelObject.supplyAirFlowRatePerFloorAreaDuringCoolingOperation(); - if (d) { - unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRatePerFloorArea, d.get()); - } - - // Fraction of Autosized Design Cooling Supply Air Flow Rate - d = modelObject.fractionofAutosizedDesignCoolingSupplyAirFlowRate(); - if (d) { - unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingFractionofAutosizedCoolingSupplyAirFlowRate, d.get()); - } - - // Design Supply Air Flow Rate Per Unit of Capacity During Cooling Operation - d = modelObject.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); - if (d) { - unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRatePerUnitofCapacity, d.get()); - } - // Supply Air Flow Rate Method During Heating Operation s = modelObject.supplyAirFlowRateMethodDuringHeatingOperation(); if (s) { diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index cbcb9472ec..addbb98584 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -48,11 +48,16 @@ #include "../utilities/core/Assert.hpp" #include "../utilities/data/DataEnums.hpp" +#include "utilities/core/Exception.hpp" #include #include #include +#include // For deprecation +#include // For deprecation +#include + namespace openstudio { namespace model { @@ -337,6 +342,10 @@ namespace model { return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio); } + bool AirLoopHVACUnitarySystem_Impl::hasCoolingCoil() const { + return !isEmpty(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName); + } + boost::optional AirLoopHVACUnitarySystem_Impl::coolingCoil() const { return getObject().getModelObjectTarget(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName); } @@ -384,9 +393,14 @@ namespace model { return getObject().getModelObjectTarget(OS_AirLoopHVAC_UnitarySystemFields::SupplementalHeatingCoilName); } - boost::optional AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringCoolingOperation() const { + std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringCoolingOperation() const { // No default, and return uninitialized if empty - return getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, false, true); + boost::optional result_ = + getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, false, true); + if (result_) { + return *result_; + } + return "None"; } boost::optional AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateDuringCoolingOperation() const { @@ -718,25 +732,27 @@ namespace model { OS_ASSERT(result); } - bool AirLoopHVACUnitarySystem_Impl::setCoolingCoil(const boost::optional& coolingCoil) { - bool result(false); - if (coolingCoil) { - result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, coolingCoil.get().handle()); - } else { - resetCoolingCoil(); - result = true; + bool AirLoopHVACUnitarySystem_Impl::setCoolingCoil(const HVACComponent& coolingCoil) { + const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, coolingCoil.handle()); + if (openstudio::istringEqual("None", supplyAirFlowRateMethodDuringCoolingOperation())) { + autosizeSupplyAirFlowRateDuringCoolingOperation(); + OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate")); } return result; } void AirLoopHVACUnitarySystem_Impl::resetCoolingCoil() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, ""); OS_ASSERT(result); + OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("None")); + resetSupplyAirFlowRateDuringCoolingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); + resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); } bool AirLoopHVACUnitarySystem_Impl::setUseDOASDXCoolingCoil(bool useDOASDXCoolingCoil) { return setBooleanFieldValue(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil, useDOASDXCoolingCoil); - ; } void AirLoopHVACUnitarySystem_Impl::resetUseDOASDXCoolingCoil() { @@ -787,107 +803,86 @@ namespace model { } bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodDuringCoolingOperation( - boost::optional supplyAirFlowRateMethodDuringCoolingOperation) { - bool result(false); - if (supplyAirFlowRateMethodDuringCoolingOperation) { - result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, - supplyAirFlowRateMethodDuringCoolingOperation.get()); - } else { - resetSupplyAirFlowRateMethodDuringCoolingOperation(); - result = true; - } + const std::string& supplyAirFlowRateMethodDuringCoolingOperation) { + const bool result = + setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, supplyAirFlowRateMethodDuringCoolingOperation); return result; } - void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateMethodDuringCoolingOperation() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, ""); - OS_ASSERT(result); - } - - bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringCoolingOperation(boost::optional supplyAirFlowRateDuringCoolingOperation) { - bool result(false); - if (supplyAirFlowRateDuringCoolingOperation) { - result = - setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, supplyAirFlowRateDuringCoolingOperation.get()); - boost::optional supplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate"); - result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation); - } else { - resetSupplyAirFlowRateDuringCoolingOperation(); - result = true; - } + bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation) { + const bool result = + setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, supplyAirFlowRateDuringCoolingOperation); + OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate")); + // resetSupplyAirFlowRateDuringCoolingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); + resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); return result; } void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateDuringCoolingOperation() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, ""); OS_ASSERT(result); } void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateDuringCoolingOperation() { - bool result; - result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, "Autosize"); - boost::optional supplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate"); - result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, "Autosize"); OS_ASSERT(result); + OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate")); + // resetSupplyAirFlowRateDuringCoolingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); + resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); } bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation( - boost::optional supplyAirFlowRatePerFloorAreaDuringCoolingOperation) { - bool result(false); - if (supplyAirFlowRatePerFloorAreaDuringCoolingOperation) { - result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, - supplyAirFlowRatePerFloorAreaDuringCoolingOperation.get()); - boost::optional supplyAirFlowRateMethodDuringCoolingOperation("FlowPerFloorArea"); - result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation); - } else { - resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); - result = true; - } + double supplyAirFlowRatePerFloorAreaDuringCoolingOperation) { + const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, + supplyAirFlowRatePerFloorAreaDuringCoolingOperation); + OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FlowPerFloorArea")); + resetSupplyAirFlowRateDuringCoolingOperation(); + // resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); + resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); return result; } void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, ""); OS_ASSERT(result); } - bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignCoolingSupplyAirFlowRate( - boost::optional fractionofAutosizedDesignCoolingSupplyAirFlowRate) { - bool result(false); - if (fractionofAutosizedDesignCoolingSupplyAirFlowRate) { - result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, - fractionofAutosizedDesignCoolingSupplyAirFlowRate.get()); - boost::optional supplyAirFlowRateMethodDuringCoolingOperation("FractionOfAutosizedCoolingValue"); - result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation); - } else { - resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); - result = true; - } + bool + AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate) { + const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, + fractionofAutosizedDesignCoolingSupplyAirFlowRate); + OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FractionOfAutosizedCoolingValue")); + resetSupplyAirFlowRateDuringCoolingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); + // resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); return result; } void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, ""); OS_ASSERT(result); } bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation( - boost::optional designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) { - bool result(false); - if (designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) { - result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, - designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation.get()); - boost::optional supplyAirFlowRateMethodDuringCoolingOperation("FlowPerCoolingCapacity"); - result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation); - } else { - resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); - result = true; - } + double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) { + const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, + designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); + OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FlowPerCoolingCapacity")); + resetSupplyAirFlowRateDuringCoolingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); + resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); + // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); return result; } void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, ""); OS_ASSERT(result); } @@ -1437,7 +1432,7 @@ namespace model { OS_ASSERT(ok); ok = setLatentLoadControl("SensibleOnlyLoadControl"); OS_ASSERT(ok); - autosizeSupplyAirFlowRateDuringCoolingOperation(); + getImpl()->setSupplyAirFlowRateMethodDuringCoolingOperation("None"); autosizeSupplyAirFlowRateDuringHeatingOperation(); autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); setMaximumSupplyAirTemperature(80.0); @@ -1577,7 +1572,7 @@ namespace model { return getImpl()->supplementalHeatingCoil(); } - boost::optional AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringCoolingOperation() const { + std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringCoolingOperation() const { return getImpl()->supplyAirFlowRateMethodDuringCoolingOperation(); } @@ -1871,23 +1866,10 @@ namespace model { getImpl()->resetSupplementalHeatingCoil(); } - bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation) { - return getImpl()->setSupplyAirFlowRateMethodDuringCoolingOperation( - supplyAirFlowRateMethodDuringCoolingOperation); - } - - void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringCoolingOperation() { - getImpl()->resetSupplyAirFlowRateMethodDuringCoolingOperation(); - } - bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation) { return getImpl()->setSupplyAirFlowRateDuringCoolingOperation(supplyAirFlowRateDuringCoolingOperation); } - void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringCoolingOperation() { - getImpl()->resetSupplyAirFlowRateDuringCoolingOperation(); - } - void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateDuringCoolingOperation() { getImpl()->autosizeSupplyAirFlowRateDuringCoolingOperation(); } @@ -1897,29 +1879,17 @@ namespace model { supplyAirFlowRatePerFloorAreaDuringCoolingOperation); } - void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() { - getImpl()->resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); - } - bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate) { return getImpl()->setFractionofAutosizedDesignCoolingSupplyAirFlowRate( fractionofAutosizedDesignCoolingSupplyAirFlowRate); } - void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() { - getImpl()->resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); - } - bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation( double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) { return getImpl()->setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation( designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); } - void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() { - getImpl()->resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); - } - bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation) { return getImpl()->setSupplyAirFlowRateMethodDuringHeatingOperation( supplyAirFlowRateMethodDuringHeatingOperation); @@ -2148,11 +2118,6 @@ namespace model { getImpl()->resetDesignSpecificationMultispeedObject(); } - /// @cond - AirLoopHVACUnitarySystem::AirLoopHVACUnitarySystem(std::shared_ptr impl) - : ZoneHVACComponent(std::move(impl)) {} - /// @endcond - boost::optional AirLoopHVACUnitarySystem::autosizedSupplyAirFlowRateDuringCoolingOperation() const { return getImpl()->autosizedSupplyAirFlowRateDuringCoolingOperation(); } @@ -2173,5 +2138,55 @@ namespace model { return getImpl()->autosizedDOASDXCoolingCoilLeavingMinimumAirTemperature(); } + /// @cond + AirLoopHVACUnitarySystem::AirLoopHVACUnitarySystem(std::shared_ptr impl) + : ZoneHVACComponent(std::move(impl)) {} + + // DEPRECATED + + bool isTimeToRemoveDeprecated() { + VersionString currentVersion(openStudioVersion()); + const bool isTimeToRemove = ((currentVersion.major() == 3) || (currentVersion > VersionString("3.9.0"))); + return isTimeToRemove; + } + + void log_deprecation_and_throw_if_time_to_remove(const std::string& methodName) { + LOG_FREE(Warn, "openstudio.model.AirLoopHVACUnitarySystem", + "As of 3.7.0, " << methodName + << " is deprecated. " + "Use one of the setSupplyAirFlowRateXXX setters instead. " + "It will be removed within three releases."); + if (isTimeToRemoveDeprecated()) { + throw openstudio::Exception(fmt::format("Time to remove {} from the API", methodName)); + } + } + + bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation) { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + return false; + } + + void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringCoolingOperation() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + + void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringCoolingOperation() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + + void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + + void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + + void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + + /// @endcond + } // namespace model } // namespace openstudio diff --git a/src/model/AirLoopHVACUnitarySystem.hpp b/src/model/AirLoopHVACUnitarySystem.hpp index 10b827507c..f1641dff40 100644 --- a/src/model/AirLoopHVACUnitarySystem.hpp +++ b/src/model/AirLoopHVACUnitarySystem.hpp @@ -33,6 +33,8 @@ #include "ModelAPI.hpp" #include "ZoneHVACComponent.hpp" +#include "../utilities/core/Deprecated.hpp" + namespace openstudio { namespace model { @@ -130,7 +132,7 @@ namespace model { boost::optional supplementalHeatingCoil() const; /** In EnergyPlus 8.3.0 and above this property maps to the EnergyPlus field "Cooling Supply Air Flow Rate Method" **/ - boost::optional supplyAirFlowRateMethodDuringCoolingOperation() const; + std::string supplyAirFlowRateMethodDuringCoolingOperation() const; /** In EnergyPlus 8.3.0 and above this property maps to the EnergyPlus field "Cooling Supply Air Flow Rate" **/ boost::optional supplyAirFlowRateDuringCoolingOperation() const; @@ -298,27 +300,21 @@ namespace model { void resetSupplementalHeatingCoil(); - bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation); - - void resetSupplyAirFlowRateMethodDuringCoolingOperation(); + OS_DEPRECATED bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation); + OS_DEPRECATED void resetSupplyAirFlowRateMethodDuringCoolingOperation(); bool setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation); - - void resetSupplyAirFlowRateDuringCoolingOperation(); - + OS_DEPRECATED void resetSupplyAirFlowRateDuringCoolingOperation(); void autosizeSupplyAirFlowRateDuringCoolingOperation(); bool setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(double supplyAirFlowRatePerFloorAreaDuringCoolingOperation); - - void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); + OS_DEPRECATED void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); bool setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate); - - void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); + OS_DEPRECATED void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); - - void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); + OS_DEPRECATED void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); bool setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation); diff --git a/src/model/AirLoopHVACUnitarySystem_Impl.hpp b/src/model/AirLoopHVACUnitarySystem_Impl.hpp index 5a37cdd9ad..8deb024561 100644 --- a/src/model/AirLoopHVACUnitarySystem_Impl.hpp +++ b/src/model/AirLoopHVACUnitarySystem_Impl.hpp @@ -114,6 +114,7 @@ namespace model { bool isDXHeatingCoilSizingRatioDefaulted() const; + bool hasCoolingCoil() const; // For speed boost::optional coolingCoil() const; bool useDOASDXCoolingCoil() const; @@ -132,7 +133,7 @@ namespace model { boost::optional supplementalHeatingCoil() const; - boost::optional supplyAirFlowRateMethodDuringCoolingOperation() const; + std::string supplyAirFlowRateMethodDuringCoolingOperation() const; boost::optional supplyAirFlowRateDuringCoolingOperation() const; @@ -276,7 +277,7 @@ namespace model { void resetDXHeatingCoilSizingRatio(); - bool setCoolingCoil(const boost::optional& coolingCoil); + bool setCoolingCoil(const HVACComponent& coolingCoil); void resetCoolingCoil(); @@ -298,26 +299,23 @@ namespace model { void resetSupplementalHeatingCoil(); - bool setSupplyAirFlowRateMethodDuringCoolingOperation(boost::optional supplyAirFlowRateMethodDuringCoolingOperation); + bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation); - void resetSupplyAirFlowRateMethodDuringCoolingOperation(); - - bool setSupplyAirFlowRateDuringCoolingOperation(boost::optional supplyAirFlowRateDuringCoolingOperation); + bool setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation); void resetSupplyAirFlowRateDuringCoolingOperation(); void autosizeSupplyAirFlowRateDuringCoolingOperation(); - bool setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(boost::optional supplyAirFlowRatePerFloorAreaDuringCoolingOperation); + bool setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(double supplyAirFlowRatePerFloorAreaDuringCoolingOperation); void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); - bool setFractionofAutosizedDesignCoolingSupplyAirFlowRate(boost::optional fractionofAutosizedDesignCoolingSupplyAirFlowRate); + bool setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate); void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); - bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation( - boost::optional designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); + bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); diff --git a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp index 887686c1a2..ca1bd1da1f 100644 --- a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp +++ b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp @@ -652,53 +652,115 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_cloneAirLoopHVAC_Nodes) { EXPECT_EQ(unitary, a.supplyComponents(openstudio::IddObjectType::OS_AirLoopHVAC_UnitarySystem)[0]); } -TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOperation) { +TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOperation_Cooling) { + // Test for #4695 - AirLoopHVACUnitarySystem: Supply Air Flow Rate Method During Operation should be set via related setters/autosize + + Model m; + AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m); + + // we've already autosized in the ctor + EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringCoolingOperation()); + ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); + EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); + + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); + + // Setting a coil changes things + CoilCoolingDXSingleSpeed cc(m); + EXPECT_TRUE(unitary.setCoolingCoil(cc)); + EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringCoolingOperation()); + EXPECT_TRUE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); + + unitary.resetCoolingCoil(); + EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringCoolingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); + // Put it back + EXPECT_TRUE(unitary.setCoolingCoil(cc)); + + // SupplyAirFlowRate + EXPECT_TRUE(unitary.setSupplyAirFlowRateDuringCoolingOperation(1.0)); + EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringCoolingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized()); + ASSERT_TRUE(unitary.supplyAirFlowRateDuringCoolingOperation()); + EXPECT_EQ(1.0, unitary.supplyAirFlowRateDuringCoolingOperation().get()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); + + // FlowPerFloorArea + EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(1.0)); + EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringCoolingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation()); + ASSERT_TRUE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation()); + EXPECT_EQ(1.0, unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation().get()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); + + // FractionOfAutosizedCoolingValue + EXPECT_TRUE(unitary.setFractionofAutosizedDesignCoolingSupplyAirFlowRate(1.0)); + EXPECT_EQ("FractionOfAutosizedCoolingValue", unitary.supplyAirFlowRateMethodDuringCoolingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation()); + ASSERT_TRUE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate()); + EXPECT_EQ(1.0, unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate().get()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); + + // FlowPerCoolingCapacity + EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(1.0)); + EXPECT_EQ("FlowPerCoolingCapacity", unitary.supplyAirFlowRateMethodDuringCoolingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate()); + ASSERT_TRUE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); + EXPECT_EQ(1.0, unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation().get()); +} + +TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOperation_Heating) { // Test for #4695 - AirLoopHVACUnitarySystem: Supply Air Flow Rate Method During Operation should be set via related setters/autosize Model m; AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m); // we've already autosized in the ctor - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation()); - EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get()); ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); // Test reset - unitary.resetSupplyAirFlowRateMethodDuringCoolingOperation(); unitary.resetSupplyAirFlowRateMethodDuringHeatingOperation(); - EXPECT_FALSE(unitary.supplyAirFlowRateMethodDuringCoolingOperation()); EXPECT_FALSE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); // SupplyAirFlowRate - EXPECT_TRUE(unitary.setSupplyAirFlowRateDuringCoolingOperation(1.0)); EXPECT_TRUE(unitary.setSupplyAirFlowRateDuringHeatingOperation(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation()); - EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get()); ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); // FlowPerFloorArea - EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(1.0)); EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation()); - EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get()); ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); // FractionOfAutosizedXXXValue - EXPECT_TRUE(unitary.setFractionofAutosizedDesignCoolingSupplyAirFlowRate(1.0)); EXPECT_TRUE(unitary.setFractionofAutosizedDesignHeatingSupplyAirFlowRate(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation()); - EXPECT_EQ("FractionOfAutosizedCoolingValue", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get()); ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_EQ("FractionOfAutosizedHeatingValue", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); // FlowPerXXXCapacity - EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(1.0)); EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation()); - EXPECT_EQ("FlowPerCoolingCapacity", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get()); ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_EQ("FlowPerHeatingCapacity", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); @@ -741,3 +803,14 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired()); EXPECT_EQ("FlowPerHeatingCapacity", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get()); } + +TEST_F(ModelFixture, AirLoopHVACUnitarySystem_needToRemoveDeprecated) { + Model m; + AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m); + EXPECT_NO_THROW(unitary.setSupplyAirFlowRateMethodDuringCoolingOperation("")); + EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateMethodDuringCoolingOperation()); + EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateDuringCoolingOperation()); + EXPECT_NO_THROW(unitary.resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation()); + EXPECT_NO_THROW(unitary.resetFractionofAutosizedDesignCoolingSupplyAirFlowRate()); + EXPECT_NO_THROW(unitary.resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); +} From 08858b4b44ffd04bc39e889ef5a9a3e8c1f64ad2 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 12 Jul 2023 09:25:36 -0700 Subject: [PATCH 02/15] Add None default to idd. --- resources/model/OpenStudio.idd | 1 + 1 file changed, 1 insertion(+) diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index c5721bd7be..176a4f71c3 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -11902,6 +11902,7 @@ OS:AirLoopHVAC:UnitarySystem, \key FlowPerFloorArea \key FractionOfAutosizedCoolingValue \key FlowPerCoolingCapacity + \default None \note Enter the method used to determine the cooling supply air volume flow rate. \note None is used when a cooling coil is not included in the unitary system or this field may be blank. \note SupplyAirFlowRate is selected when the magnitude of the supply air volume is used. From fa7543ae41f80e190dd98d78c31d4cce4f19d9bf Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 12 Jul 2023 09:26:32 -0700 Subject: [PATCH 03/15] Simplify method getter after introducing None default. --- src/model/AirLoopHVACUnitarySystem.cpp | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index d72cff38eb..99149ccab3 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -370,13 +370,9 @@ namespace model { } std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringCoolingOperation() const { - // No default, and return uninitialized if empty - boost::optional result_ = - getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, false, true); - if (result_) { - return *result_; - } - return "None"; + boost::optional value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, true); + OS_ASSERT(value); + return value.get(); } boost::optional AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateDuringCoolingOperation() const { From d3d1f3dab8ded71af3ed49ee1c7d01f17e9acab0 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 07:22:58 -0700 Subject: [PATCH 04/15] Add None default for HeatingOperation. --- resources/model/OpenStudio.idd | 1 + src/model/AirLoopHVACUnitarySystem.cpp | 5 +++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index 176a4f71c3..6efd3a1187 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -11947,6 +11947,7 @@ OS:AirLoopHVAC:UnitarySystem, \key FlowPerFloorArea \key FractionOfAutosizedHeatingValue \key FlowPerHeatingCapacity + \default None \note Enter the method used to determine the heating supply air volume flow rate. \note None is used when a heating coil is not included in the unitary system or this field may be blank. \note SupplyAirFlowRate is selected when the magnitude of the supply air volume is used. diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index 99149ccab3..4aff828ea9 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -401,8 +401,9 @@ namespace model { } boost::optional AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringHeatingOperation() const { - // No default, and return uninitialized if empty - return getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, false, true); + boost::optional value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, true); + OS_ASSERT(value); + return value.get(); } boost::optional AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateDuringHeatingOperation() const { From b54af033d2c7e55c48008dff6ac5a3ffafda93ca Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 09:23:21 -0700 Subject: [PATCH 05/15] Updates for new os_deprecated method args. --- src/model/AirLoopHVACUnitarySystem.hpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/model/AirLoopHVACUnitarySystem.hpp b/src/model/AirLoopHVACUnitarySystem.hpp index a711971fff..ace434c8e5 100644 --- a/src/model/AirLoopHVACUnitarySystem.hpp +++ b/src/model/AirLoopHVACUnitarySystem.hpp @@ -276,21 +276,21 @@ namespace model { void resetSupplementalHeatingCoil(); - OS_DEPRECATED bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation); - OS_DEPRECATED void resetSupplyAirFlowRateMethodDuringCoolingOperation(); + OS_DEPRECATED(3, 5, 1) bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation); + OS_DEPRECATED(3, 5, 1) void resetSupplyAirFlowRateMethodDuringCoolingOperation(); bool setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation); - OS_DEPRECATED void resetSupplyAirFlowRateDuringCoolingOperation(); + OS_DEPRECATED(3, 5, 1) void resetSupplyAirFlowRateDuringCoolingOperation(); void autosizeSupplyAirFlowRateDuringCoolingOperation(); bool setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(double supplyAirFlowRatePerFloorAreaDuringCoolingOperation); - OS_DEPRECATED void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); + OS_DEPRECATED(3, 5, 1) void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); bool setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate); - OS_DEPRECATED void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); + OS_DEPRECATED(3, 5, 1) void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); - OS_DEPRECATED void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); + OS_DEPRECATED(3, 5, 1) void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); bool setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation); From dd0bd1a4431ef886641dcc2c3c05396a8a6e5e15 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 10:30:57 -0700 Subject: [PATCH 06/15] Update ft for heating. --- ...rwardTranslateAirLoopHVACUnitarySystem.cpp | 59 +++++++++---------- src/model/AirLoopHVACUnitarySystem.hpp | 12 ++-- 2 files changed, 34 insertions(+), 37 deletions(-) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp index bc12384531..e4002ce976 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp @@ -197,6 +197,34 @@ namespace energyplus { unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingCoilObjectType, _heatingCoil->iddObject().name()); unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingCoilName, _heatingCoil->name().get()); } + + // Supply Air Flow Rate Method During Heating Operation + unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRateMethod, + modelObject.supplyAirFlowRateMethodDuringHeatingOperation()); + + // Supply Air Flow Rate During Heating Operation + if (modelObject.isSupplyAirFlowRateDuringHeatingOperationAutosized()) { + unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRate, "Autosize"); + } else if (auto val_ = modelObject.supplyAirFlowRateDuringHeatingOperation()) { + unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRate, val_.get()); + } + + // Supply Air Flow Rate Per Floor Area during Heating Operation + if (auto val_ = modelObject.supplyAirFlowRatePerFloorAreaduringHeatingOperation()) { + unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRatePerFloorArea, val_.get()); + } + + // Fraction of Autosized Design Heating Supply Air Flow Rate + if (auto val_ = modelObject.fractionofAutosizedDesignHeatingSupplyAirFlowRate()) { + unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingFractionofAutosizedHeatingSupplyAirFlowRate, val_.get()); + } + + // Design Supply Air Flow Rate Per Unit of Capacity During Heating Operation + if (auto val_ = modelObject.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()) { + unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRatePerUnitofCapacity, val_.get()); + } + } else { + unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRateMethod, "None"); } // DX Heating Coil Sizing Ratio @@ -280,37 +308,6 @@ namespace energyplus { } } - // Supply Air Flow Rate Method During Heating Operation - s = modelObject.supplyAirFlowRateMethodDuringHeatingOperation(); - if (s) { - unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRateMethod, s.get()); - } - - // Supply Air Flow Rate During Heating Operation - if (modelObject.isSupplyAirFlowRateDuringHeatingOperationAutosized()) { - unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRate, "Autosize"); - } else if ((d = modelObject.supplyAirFlowRateDuringHeatingOperation())) { - unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRate, d.get()); - } - - // Supply Air Flow Rate Per Floor Area during Heating Operation - d = modelObject.supplyAirFlowRatePerFloorAreaduringHeatingOperation(); - if (d) { - unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRatePerFloorArea, d.get()); - } - - // Fraction of Autosized Design Heating Supply Air Flow Rate - d = modelObject.fractionofAutosizedDesignHeatingSupplyAirFlowRate(); - if (d) { - unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingFractionofAutosizedHeatingSupplyAirFlowRate, d.get()); - } - - // Design Supply Air Flow Rate Per Unit of Capacity During Heating Operation - d = modelObject.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); - if (d) { - unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRatePerUnitofCapacity, d.get()); - } - // Supply Air Flow Rate Method When No Cooling or Heating is Required s = modelObject.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(); if (s) { diff --git a/src/model/AirLoopHVACUnitarySystem.hpp b/src/model/AirLoopHVACUnitarySystem.hpp index ace434c8e5..55fee6abb3 100644 --- a/src/model/AirLoopHVACUnitarySystem.hpp +++ b/src/model/AirLoopHVACUnitarySystem.hpp @@ -276,21 +276,21 @@ namespace model { void resetSupplementalHeatingCoil(); - OS_DEPRECATED(3, 5, 1) bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation); - OS_DEPRECATED(3, 5, 1) void resetSupplyAirFlowRateMethodDuringCoolingOperation(); + OS_DEPRECATED(3, 7, 0) bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation); + OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRateMethodDuringCoolingOperation(); bool setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation); - OS_DEPRECATED(3, 5, 1) void resetSupplyAirFlowRateDuringCoolingOperation(); + OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRateDuringCoolingOperation(); void autosizeSupplyAirFlowRateDuringCoolingOperation(); bool setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(double supplyAirFlowRatePerFloorAreaDuringCoolingOperation); - OS_DEPRECATED(3, 5, 1) void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); + OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(); bool setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate); - OS_DEPRECATED(3, 5, 1) void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); + OS_DEPRECATED(3, 7, 0) void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate(); bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); - OS_DEPRECATED(3, 5, 1) void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); + OS_DEPRECATED(3, 7, 0) void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); bool setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation); From 01ee57baf4a42091dff6c6b9414d04d02fcc5aae Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 11:08:08 -0700 Subject: [PATCH 07/15] Update all heating methods. --- src/model/AirLoopHVACUnitarySystem.cpp | 191 ++++++++---------- src/model/AirLoopHVACUnitarySystem.hpp | 20 +- src/model/AirLoopHVACUnitarySystem_Impl.hpp | 15 +- .../test/AirLoopHVACUnitarySystem_GTest.cpp | 118 ++++++----- 4 files changed, 167 insertions(+), 177 deletions(-) diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index 4aff828ea9..4ab57cf22a 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -304,6 +304,10 @@ namespace model { return getObject().getModelObjectTarget(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName); } + bool AirLoopHVACUnitarySystem_Impl::hasHeatingCoil() const { + return !isEmpty(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName); + } + boost::optional AirLoopHVACUnitarySystem_Impl::heatingCoil() const { return getObject().getModelObjectTarget(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName); } @@ -400,7 +404,7 @@ namespace model { return getDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, true); } - boost::optional AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringHeatingOperation() const { + std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringHeatingOperation() const { boost::optional value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, true); OS_ASSERT(value); return value.get(); @@ -679,20 +683,23 @@ namespace model { OS_ASSERT(result); } - bool AirLoopHVACUnitarySystem_Impl::setHeatingCoil(const boost::optional& heatingCoil) { - bool result(false); - if (heatingCoil) { - result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, heatingCoil.get().handle()); - } else { - resetHeatingCoil(); - result = true; + bool AirLoopHVACUnitarySystem_Impl::setHeatingCoil(const HVACComponent& heatingCoil) { + const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, heatingCoil.handle()); + if (openstudio::istringEqual("None", supplyAirFlowRateMethodDuringHeatingOperation())) { + autosizeSupplyAirFlowRateDuringHeatingOperation(); + OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate")); } return result; } void AirLoopHVACUnitarySystem_Impl::resetHeatingCoil() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, ""); OS_ASSERT(result); + OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("None")); + resetSupplyAirFlowRateDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); } bool AirLoopHVACUnitarySystem_Impl::setDXHeatingCoilSizingRatio(double dXHeatingCoilSizingRatio) { @@ -860,107 +867,85 @@ namespace model { } bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodDuringHeatingOperation( - boost::optional supplyAirFlowRateMethodDuringHeatingOperation) { - bool result(false); - if (supplyAirFlowRateMethodDuringHeatingOperation) { - result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, - supplyAirFlowRateMethodDuringHeatingOperation.get()); - } else { - resetSupplyAirFlowRateMethodDuringHeatingOperation(); - result = true; - } + const std::string& supplyAirFlowRateMethodDuringHeatingOperation) { + const bool result = + setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, supplyAirFlowRateMethodDuringHeatingOperation); return result; } - void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateMethodDuringHeatingOperation() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, ""); - OS_ASSERT(result); - } - - bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringHeatingOperation(boost::optional supplyAirFlowRateDuringHeatingOperation) { - bool result(false); - if (supplyAirFlowRateDuringHeatingOperation) { - result = - setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, supplyAirFlowRateDuringHeatingOperation.get()); - boost::optional supplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate"); - result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation); - } else { - resetSupplyAirFlowRateDuringHeatingOperation(); - result = true; - } + bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation) { + const bool result = + setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, supplyAirFlowRateDuringHeatingOperation); + OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate")); + // resetSupplyAirFlowRateDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); return result; } void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateDuringHeatingOperation() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, ""); OS_ASSERT(result); } void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateDuringHeatingOperation() { - bool result; - result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, "Autosize"); - boost::optional supplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate"); - result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, "Autosize"); OS_ASSERT(result); + OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate")); + // resetSupplyAirFlowRateDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); } bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaduringHeatingOperation( - boost::optional supplyAirFlowRatePerFloorAreaduringHeatingOperation) { - bool result(false); - if (supplyAirFlowRatePerFloorAreaduringHeatingOperation) { - result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, - supplyAirFlowRatePerFloorAreaduringHeatingOperation.get()); - boost::optional supplyAirFlowRateMethodDuringHeatingOperation("FlowPerFloorArea"); - result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation); - } else { - resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); - result = true; - } + double supplyAirFlowRatePerFloorAreaDuringHeatingOperation) { + const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringHeatingOperation, + supplyAirFlowRatePerFloorAreaDuringHeatingOperation); + OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerFloorArea")); + resetSupplyAirFlowRateDuringHeatingOperation(); + // resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); return result; } void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringHeatingOperation, ""); OS_ASSERT(result); } - bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRate( - boost::optional fractionofAutosizedDesignHeatingSupplyAirFlowRate) { - bool result(false); - if (fractionofAutosizedDesignHeatingSupplyAirFlowRate) { - result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, - fractionofAutosizedDesignHeatingSupplyAirFlowRate.get()); - boost::optional supplyAirFlowRateMethodDuringHeatingOperation("FractionOfAutosizedHeatingValue"); - result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation); - } else { - resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); - result = true; - } + bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) { + const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, + fractionofAutosizedDesignHeatingSupplyAirFlowRate); + OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FractionOfAutosizedHeatingValue")); + resetSupplyAirFlowRateDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + // resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); + resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); return result; } void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, ""); OS_ASSERT(result); } bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation( - boost::optional designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) { - bool result(false); - if (designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) { - result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, - designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation.get()); - boost::optional supplyAirFlowRateMethodDuringHeatingOperation("FlowPerHeatingCapacity"); - result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation); - } else { - resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); - result = true; - } + double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) { + const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, + designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation); + OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerHeatingCapacity")); + resetSupplyAirFlowRateDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); + // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); return result; } void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() { - bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, ""); OS_ASSERT(result); } @@ -1406,7 +1391,7 @@ namespace model { ok = setLatentLoadControl("SensibleOnlyLoadControl"); OS_ASSERT(ok); getImpl()->setSupplyAirFlowRateMethodDuringCoolingOperation("None"); - autosizeSupplyAirFlowRateDuringHeatingOperation(); + getImpl()->setSupplyAirFlowRateMethodDuringHeatingOperation("None"); autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(); setMaximumSupplyAirTemperature(80.0); setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(21.0); @@ -1569,7 +1554,7 @@ namespace model { return getImpl()->designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); } - boost::optional AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringHeatingOperation() const { + std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringHeatingOperation() const { return getImpl()->supplyAirFlowRateMethodDuringHeatingOperation(); } @@ -1863,23 +1848,10 @@ namespace model { designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); } - bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation) { - return getImpl()->setSupplyAirFlowRateMethodDuringHeatingOperation( - supplyAirFlowRateMethodDuringHeatingOperation); - } - - void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringHeatingOperation() { - getImpl()->resetSupplyAirFlowRateMethodDuringHeatingOperation(); - } - bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation) { return getImpl()->setSupplyAirFlowRateDuringHeatingOperation(supplyAirFlowRateDuringHeatingOperation); } - void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringHeatingOperation() { - getImpl()->resetSupplyAirFlowRateDuringHeatingOperation(); - } - void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateDuringHeatingOperation() { getImpl()->autosizeSupplyAirFlowRateDuringHeatingOperation(); } @@ -1889,29 +1861,17 @@ namespace model { supplyAirFlowRatePerFloorAreaduringHeatingOperation); } - void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() { - getImpl()->resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); - } - bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) { return getImpl()->setFractionofAutosizedDesignHeatingSupplyAirFlowRate( fractionofAutosizedDesignHeatingSupplyAirFlowRate); } - void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() { - getImpl()->resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); - } - bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation( double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) { return getImpl()->setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation( designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation); } - void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() { - getImpl()->resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); - } - bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired( const std::string& supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired) { return getImpl()->setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired( @@ -2159,6 +2119,31 @@ namespace model { log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } + bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation) { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + return false; + } + + void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringHeatingOperation() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + + void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringHeatingOperation() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + + void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + + void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + + void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() { + log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + } + /// @endcond } // namespace model diff --git a/src/model/AirLoopHVACUnitarySystem.hpp b/src/model/AirLoopHVACUnitarySystem.hpp index 55fee6abb3..a906a23c16 100644 --- a/src/model/AirLoopHVACUnitarySystem.hpp +++ b/src/model/AirLoopHVACUnitarySystem.hpp @@ -125,7 +125,7 @@ namespace model { boost::optional designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() const; /** In EnergyPlus 8.3.0 and above this property maps to the EnergyPlus field "Heating Supply Air Flow Rate Method" **/ - boost::optional supplyAirFlowRateMethodDuringHeatingOperation() const; + std::string supplyAirFlowRateMethodDuringHeatingOperation() const; /** In EnergyPlus 8.3.0 and above this property maps to the EnergyPlus field "Heating Supply Air Flow Rate" **/ boost::optional supplyAirFlowRateDuringHeatingOperation() const; @@ -292,27 +292,21 @@ namespace model { bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation); OS_DEPRECATED(3, 7, 0) void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); - bool setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation); - - void resetSupplyAirFlowRateMethodDuringHeatingOperation(); + OS_DEPRECATED(3, 7, 0) bool setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation); + OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRateMethodDuringHeatingOperation(); bool setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation); - - void resetSupplyAirFlowRateDuringHeatingOperation(); - + OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRateDuringHeatingOperation(); void autosizeSupplyAirFlowRateDuringHeatingOperation(); bool setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(double supplyAirFlowRatePerFloorAreaduringHeatingOperation); - - void resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); + OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); bool setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate); - - void resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); + OS_DEPRECATED(3, 7, 0) void resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation); - - void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); + OS_DEPRECATED(3, 7, 0) void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); bool setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(const std::string& supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired); diff --git a/src/model/AirLoopHVACUnitarySystem_Impl.hpp b/src/model/AirLoopHVACUnitarySystem_Impl.hpp index 37088ecfcb..49cb3f5d9f 100644 --- a/src/model/AirLoopHVACUnitarySystem_Impl.hpp +++ b/src/model/AirLoopHVACUnitarySystem_Impl.hpp @@ -121,7 +121,7 @@ namespace model { boost::optional designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() const; - boost::optional supplyAirFlowRateMethodDuringHeatingOperation() const; + std::string supplyAirFlowRateMethodDuringHeatingOperation() const; boost::optional supplyAirFlowRateDuringHeatingOperation() const; @@ -245,7 +245,7 @@ namespace model { void resetSupplyAirFanOperatingModeSchedule(); - bool setHeatingCoil(const boost::optional& heatingCoil); + bool setHeatingCoil(const HVACComponent& heatingCoil); void resetHeatingCoil(); @@ -295,26 +295,25 @@ namespace model { void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(); - bool setSupplyAirFlowRateMethodDuringHeatingOperation(boost::optional supplyAirFlowRateMethodDuringHeatingOperation); + bool setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation); void resetSupplyAirFlowRateMethodDuringHeatingOperation(); - bool setSupplyAirFlowRateDuringHeatingOperation(boost::optional supplyAirFlowRateDuringHeatingOperation); + bool setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation); void resetSupplyAirFlowRateDuringHeatingOperation(); void autosizeSupplyAirFlowRateDuringHeatingOperation(); - bool setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(boost::optional supplyAirFlowRatePerFloorAreaduringHeatingOperation); + bool setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(double supplyAirFlowRatePerFloorAreaduringHeatingOperation); void resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); - bool setFractionofAutosizedDesignHeatingSupplyAirFlowRate(boost::optional fractionofAutosizedDesignHeatingSupplyAirFlowRate); + bool setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate); void resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); - bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation( - boost::optional designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation); + bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation); void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); diff --git a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp index 9cc58aae19..17c8da728f 100644 --- a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp +++ b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp @@ -713,80 +713,92 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m); // we've already autosized in the ctor + EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); - // Test reset - unitary.resetSupplyAirFlowRateMethodDuringHeatingOperation(); - EXPECT_FALSE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); - // SupplyAirFlowRate - EXPECT_TRUE(unitary.setSupplyAirFlowRateDuringHeatingOperation(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); - EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); - - // FlowPerFloorArea - EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); - EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); - - // FractionOfAutosizedXXXValue - EXPECT_TRUE(unitary.setFractionofAutosizedDesignHeatingSupplyAirFlowRate(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); - EXPECT_EQ("FractionOfAutosizedHeatingValue", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); - - // FlowPerXXXCapacity - EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); - EXPECT_EQ("FlowPerHeatingCapacity", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); - - // When No Cooling or Heating is Required - // we've already autosized in the ctor - ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired()); - EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get()); - - // Test reset - unitary.resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(); - EXPECT_FALSE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired()); + // Setting a coil changes things + CoilHeatingDXSingleSpeed cc(m); + EXPECT_TRUE(unitary.setHeatingCoil(cc)); + EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); + EXPECT_TRUE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); + + unitary.resetHeatingCoil(); + EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); + // Put it back + EXPECT_TRUE(unitary.setHeatingCoil(cc)); // SupplyAirFlowRate - EXPECT_TRUE(unitary.setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired()); - EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get()); + EXPECT_TRUE(unitary.setSupplyAirFlowRateDuringHeatingOperation(1.0)); + EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); + ASSERT_TRUE(unitary.supplyAirFlowRateDuringHeatingOperation()); + EXPECT_EQ(1.0, unitary.supplyAirFlowRateDuringHeatingOperation().get()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); // FlowPerFloorArea - EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired()); - EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get()); - - // FractionOfAutosizedCoolingValue - EXPECT_TRUE(unitary.setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired()); - EXPECT_EQ("FractionOfAutosizedCoolingValue", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get()); + EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(1.0)); + EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); + ASSERT_TRUE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_EQ(1.0, unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation().get()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); // FractionOfAutosizedHeatingValue - EXPECT_TRUE(unitary.setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired()); - EXPECT_EQ("FractionOfAutosizedHeatingValue", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get()); - - // FlowPerCoolingCapacity - EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired()); - EXPECT_EQ("FlowPerCoolingCapacity", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get()); + EXPECT_TRUE(unitary.setFractionofAutosizedDesignHeatingSupplyAirFlowRate(1.0)); + EXPECT_EQ("FractionOfAutosizedHeatingValue", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + ASSERT_TRUE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); + EXPECT_EQ(1.0, unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate().get()); + EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); // FlowPerHeatingCapacity - EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(1.0)); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired()); - EXPECT_EQ("FlowPerHeatingCapacity", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get()); + EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(1.0)); + EXPECT_EQ("FlowPerHeatingCapacity", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); + EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); + EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); + ASSERT_TRUE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); + EXPECT_EQ(1.0, unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation().get()); } TEST_F(ModelFixture, AirLoopHVACUnitarySystem_needToRemoveDeprecated) { Model m; AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m); + EXPECT_NO_THROW(unitary.setSupplyAirFlowRateMethodDuringCoolingOperation("")); EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateMethodDuringCoolingOperation()); EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateDuringCoolingOperation()); EXPECT_NO_THROW(unitary.resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation()); EXPECT_NO_THROW(unitary.resetFractionofAutosizedDesignCoolingSupplyAirFlowRate()); EXPECT_NO_THROW(unitary.resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); + + EXPECT_NO_THROW(unitary.setSupplyAirFlowRateMethodDuringHeatingOperation("")); + EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateMethodDuringHeatingOperation()); + EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateDuringHeatingOperation()); + EXPECT_NO_THROW(unitary.resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_NO_THROW(unitary.resetFractionofAutosizedDesignHeatingSupplyAirFlowRate()); + EXPECT_NO_THROW(unitary.resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); } From da09bd9f80b58ddd826f9dc75d7705633656429c Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 11:08:43 -0700 Subject: [PATCH 08/15] Formatting. --- .../ForwardTranslateAirLoopHVACUnitarySystem.cpp | 2 +- src/model/AirLoopHVACUnitarySystem.cpp | 3 ++- src/model/test/AirLoopHVACUnitarySystem_GTest.cpp | 2 +- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp index e4002ce976..e087090796 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp @@ -222,7 +222,7 @@ namespace energyplus { // Design Supply Air Flow Rate Per Unit of Capacity During Heating Operation if (auto val_ = modelObject.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()) { unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRatePerUnitofCapacity, val_.get()); - } + } } else { unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRateMethod, "None"); } diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index 4ab57cf22a..502212ef0e 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -916,7 +916,8 @@ namespace model { OS_ASSERT(result); } - bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) { + bool + AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) { const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, fractionofAutosizedDesignHeatingSupplyAirFlowRate); OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FractionOfAutosizedHeatingValue")); diff --git a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp index 17c8da728f..eb3cb04783 100644 --- a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp +++ b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp @@ -794,7 +794,7 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_needToRemoveDeprecated) { EXPECT_NO_THROW(unitary.resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation()); EXPECT_NO_THROW(unitary.resetFractionofAutosizedDesignCoolingSupplyAirFlowRate()); EXPECT_NO_THROW(unitary.resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()); - + EXPECT_NO_THROW(unitary.setSupplyAirFlowRateMethodDuringHeatingOperation("")); EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateDuringHeatingOperation()); From 79b6ca34641dc76289d8dfcb32617ebff774b5d5 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 11:26:36 -0700 Subject: [PATCH 09/15] Clean up minor typos. --- src/model/AirLoopHVACUnitarySystem.cpp | 14 +++++++------- src/model/AirLoopHVACUnitarySystem_Impl.hpp | 1 + 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index 502212ef0e..9f57af7bf2 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -697,7 +697,7 @@ namespace model { OS_ASSERT(result); OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("None")); resetSupplyAirFlowRateDuringHeatingOperation(); - resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); } @@ -878,7 +878,7 @@ namespace model { setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, supplyAirFlowRateDuringHeatingOperation); OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate")); // resetSupplyAirFlowRateDuringHeatingOperation(); - resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); return result; @@ -894,7 +894,7 @@ namespace model { OS_ASSERT(result); OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate")); // resetSupplyAirFlowRateDuringHeatingOperation(); - resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); } @@ -905,14 +905,14 @@ namespace model { supplyAirFlowRatePerFloorAreaDuringHeatingOperation); OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerFloorArea")); resetSupplyAirFlowRateDuringHeatingOperation(); - // resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + // resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); return result; } void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() { - const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringHeatingOperation, ""); + const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, ""); OS_ASSERT(result); } @@ -939,7 +939,7 @@ namespace model { designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation); OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerHeatingCapacity")); resetSupplyAirFlowRateDuringHeatingOperation(); - resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); return result; @@ -2133,7 +2133,7 @@ namespace model { log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } - void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation() { + void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() { log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } diff --git a/src/model/AirLoopHVACUnitarySystem_Impl.hpp b/src/model/AirLoopHVACUnitarySystem_Impl.hpp index 49cb3f5d9f..f56ba5209a 100644 --- a/src/model/AirLoopHVACUnitarySystem_Impl.hpp +++ b/src/model/AirLoopHVACUnitarySystem_Impl.hpp @@ -84,6 +84,7 @@ namespace model { boost::optional supplyAirFanOperatingModeSchedule() const; + bool hasHeatingCoil() const; // For speed boost::optional heatingCoil() const; double dXHeatingCoilSizingRatio() const; From 57d142da97caa26a243ff3b0dafab10693f7dc99 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 12:03:03 -0700 Subject: [PATCH 10/15] More case typos. --- src/model/AirLoopHVACUnitarySystem.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index 9f57af7bf2..d0e86c2ebd 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -901,7 +901,7 @@ namespace model { bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaduringHeatingOperation( double supplyAirFlowRatePerFloorAreaDuringHeatingOperation) { - const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringHeatingOperation, + const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, supplyAirFlowRatePerFloorAreaDuringHeatingOperation); OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerFloorArea")); resetSupplyAirFlowRateDuringHeatingOperation(); @@ -922,7 +922,7 @@ namespace model { fractionofAutosizedDesignHeatingSupplyAirFlowRate); OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FractionOfAutosizedHeatingValue")); resetSupplyAirFlowRateDuringHeatingOperation(); - resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(); + resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation(); // resetFractionofAutosizedDesignHeatingSupplyAirFlowRate(); resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(); return result; From fd3d02581cf54dba993741f6ec9b330e30b08b49 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 13:20:20 -0700 Subject: [PATCH 11/15] Update model tests. --- src/model/test/AirLoopHVACUnitarySystem_GTest.cpp | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp index eb3cb04783..ce4cd8417c 100644 --- a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp +++ b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp @@ -634,10 +634,7 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera Model m; AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m); - // we've already autosized in the ctor EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringCoolingOperation()); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); - EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized()); EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation()); @@ -712,10 +709,7 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera Model m; AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m); - // we've already autosized in the ctor EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); - ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation()); - EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get()); EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); From 14133298012ff2875419c8559d50ca3ddc3618f2 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 14:40:46 -0700 Subject: [PATCH 12/15] More case typos. --- .../test/AirLoopHVACUnitarySystem_GTest.cpp | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp index ce4cd8417c..43f275c1b8 100644 --- a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp +++ b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp @@ -713,7 +713,7 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); - EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation()); EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); @@ -723,7 +723,7 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_TRUE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); - EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation()); EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); @@ -731,7 +731,7 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); - EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation()); EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); // Put it back @@ -743,17 +743,17 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); ASSERT_TRUE(unitary.supplyAirFlowRateDuringHeatingOperation()); EXPECT_EQ(1.0, unitary.supplyAirFlowRateDuringHeatingOperation().get()); - EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation()); EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); // FlowPerFloorArea - EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaDuringHeatingOperation(1.0)); + EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(1.0)); EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); - ASSERT_TRUE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); - EXPECT_EQ(1.0, unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation().get()); + ASSERT_TRUE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation()); + EXPECT_EQ(1.0, unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation().get()); EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); @@ -762,7 +762,7 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera EXPECT_EQ("FractionOfAutosizedHeatingValue", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); - EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation()); ASSERT_TRUE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); EXPECT_EQ(1.0, unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate().get()); EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); @@ -772,7 +772,7 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOpera EXPECT_EQ("FlowPerHeatingCapacity", unitary.supplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized()); EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation()); - EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation()); EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate()); ASSERT_TRUE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); EXPECT_EQ(1.0, unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation().get()); @@ -792,7 +792,7 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_needToRemoveDeprecated) { EXPECT_NO_THROW(unitary.setSupplyAirFlowRateMethodDuringHeatingOperation("")); EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateMethodDuringHeatingOperation()); EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateDuringHeatingOperation()); - EXPECT_NO_THROW(unitary.resetSupplyAirFlowRatePerFloorAreaDuringHeatingOperation()); + EXPECT_NO_THROW(unitary.resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation()); EXPECT_NO_THROW(unitary.resetFractionofAutosizedDesignHeatingSupplyAirFlowRate()); EXPECT_NO_THROW(unitary.resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()); } From 2cef40d783fd9efee17196928087a2e7282813eb Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 13 Jul 2023 15:18:14 -0700 Subject: [PATCH 13/15] Stub deprecated_at_msg in cpp. --- src/model/AirLoopHVACUnitarySystem.cpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index d0e86c2ebd..8c8a20b82c 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -2096,52 +2096,64 @@ namespace model { } bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation) { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); return false; } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringCoolingOperation() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringCoolingOperation() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation) { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); return false; } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringHeatingOperation() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringHeatingOperation() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() { + //DEPRECATED_AT_MSG(3, 7, 0, ""); log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); } From df44eab39d9a4010487a3c7c20582c0f516bd4be Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Fri, 14 Jul 2023 07:49:53 -0700 Subject: [PATCH 14/15] Update deprecated messages. --- src/model/AirLoopHVACUnitarySystem.cpp | 86 +++++++++++++------------- 1 file changed, 44 insertions(+), 42 deletions(-) diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index 8c8a20b82c..43a69d52ef 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -2077,84 +2077,86 @@ namespace model { : ZoneHVACComponent(std::move(impl)) {} // DEPRECATED - - bool isTimeToRemoveDeprecated() { - VersionString currentVersion(openStudioVersion()); - const bool isTimeToRemove = ((currentVersion.major() == 3) || (currentVersion > VersionString("3.9.0"))); - return isTimeToRemove; - } - - void log_deprecation_and_throw_if_time_to_remove(const std::string& methodName) { - LOG_FREE(Warn, "openstudio.model.AirLoopHVACUnitarySystem", - "As of 3.7.0, " << methodName - << " is deprecated. " - "Use one of the setSupplyAirFlowRateXXX setters instead. " - "It will be removed within three releases."); - if (isTimeToRemoveDeprecated()) { - throw openstudio::Exception(fmt::format("Time to remove {} from the API", methodName)); - } - } - bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation) { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG(3, 7, 0, + "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " + "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or " + "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); return false; } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringCoolingOperation() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG(3, 7, 0, + "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " + "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or " + "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringCoolingOperation() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG(3, 7, 0, + "Use setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or " + "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG( + 3, 7, 0, + "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " + "setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); } void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG( + 3, 7, 0, + "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " + "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead."); } void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG(3, 7, 0, + "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, " + "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, or setFractionofAutosizedDesignCoolingSupplyAirFlowRate instead."); } bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation) { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG(3, 7, 0, + "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " + "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or " + "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); return false; } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringHeatingOperation() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG(3, 7, 0, + "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " + "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or " + "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringHeatingOperation() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG(3, 7, 0, + "Use setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or " + "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); } void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG( + 3, 7, 0, + "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " + "setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); } void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG( + 3, 7, 0, + "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " + "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead."); } void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() { - //DEPRECATED_AT_MSG(3, 7, 0, ""); - log_deprecation_and_throw_if_time_to_remove(BOOST_CURRENT_FUNCTION); + DEPRECATED_AT_MSG(3, 7, 0, + "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, " + "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, or setFractionofAutosizedDesignHeatingSupplyAirFlowRate instead."); } /// @endcond From 36a9a7d971ca9c0efffe6fb98a2824ec870f72ff Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Fri, 14 Jul 2023 08:10:48 -0700 Subject: [PATCH 15/15] Include deprecatedhelpers hpp. --- src/model/AirLoopHVACUnitarySystem.cpp | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp index 43a69d52ef..02fdd8168c 100644 --- a/src/model/AirLoopHVACUnitarySystem.cpp +++ b/src/model/AirLoopHVACUnitarySystem.cpp @@ -30,9 +30,7 @@ #include #include -#include // For deprecation -#include // For deprecation -#include +#include "../utilities/core/DeprecatedHelpers.hpp" namespace openstudio { namespace model {