From 588f712b34f0e9345ab6dfb57535c13b175bfebc Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 6 Sep 2023 12:50:15 -0700 Subject: [PATCH 01/18] Updates to idd files. --- resources/energyplus/ProposedEnergy+.idd | 4 +- resources/model/OpenStudio.idd | 48 +++++++++++++++++++++++- 2 files changed, 48 insertions(+), 4 deletions(-) diff --git a/resources/energyplus/ProposedEnergy+.idd b/resources/energyplus/ProposedEnergy+.idd index 1525d87d055..961877f9e97 100644 --- a/resources/energyplus/ProposedEnergy+.idd +++ b/resources/energyplus/ProposedEnergy+.idd @@ -44880,12 +44880,12 @@ HeatPump:PlantLoop:EIR:Cooling, \note The unit is disabled above this temperature. N9, \field Minimum Supply Water Temperature Curve Name \type object-list - \object-list UniVariateFunctions + \object-list UnivariateFunctions \note quadratic curve = a + b*OAT is typical, other univariate curves may be used \note OAT = Outdoor Dry-Bulb Temperature N10; \field Maximum Supply Water Temperature Curve Name \type object-list - \object-list UniVariateFunctions + \object-list UnivariateFunctions \note quadratic curve = a + b*OAT is typical, other univariate curves may be used \note OAT = Outdoor Dry-Bulb Temperature diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index 26c0e37ee46..5b73f9aa35a 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -14066,7 +14066,7 @@ OS:HeatPump:PlantLoop:EIR:Heating, OS:HeatPump:PlantLoop:EIR:Cooling, \memo An EIR formulated water to water heat pump model, cooling operation. - \min-fields 16 + \min-fields 21 A1, \field Handle \type handle \required-field @@ -14152,7 +14152,7 @@ OS:HeatPump:PlantLoop:EIR:Cooling, \note curve = a + b*CWS + c*CWS**2 + d*ECT + e*ECT**2 + f*CWS*ECT \note CWS = supply (leaving) chilled water temperature(C) \note ECT = entering condenser fluid temperature(C) - A11;\field Electric Input to Output Ratio Modifier Function of Part Load Ratio Curve Name + A11,\field Electric Input to Output Ratio Modifier Function of Part Load Ratio Curve Name \note Electric Input Ratio (EIR) modifier as a function of Part Load Ratio (PLR) \note EIR = 1/COP \required-field @@ -14160,6 +14160,50 @@ OS:HeatPump:PlantLoop:EIR:Cooling, \object-list UnivariateFunctions \note quadratic curve = a + b*PLR + c*PLR**2 is typical, other univariate curves may be used \note PLR = part load ratio (cooling load/steady state capacity) + A12,\field Control Type + \note Heat pump can be controlled on leaving water temperature set point or plant load + \type choice + \key Setpoint + \key Load + \required-field + A13,\field Flow Mode + \note Select operating mode for fluid flow through the chiller. "ConstantFlow" is for + \note constant pumping with flow controlled by chiller to operate at full design + \note flow rate. "VariableSpeedPumping" is for variable pumping with flow proportional + \note to chiller operating part load ratio. + \type choice + \key ConstantFlow + \key VariableSpeedPumping + \required-field + N6, \field Minimum Part Load Ratio + \note Below this operating limit compressor cycling will occur + \type real + \minimum 0.0 + \required-field + N7, \field Minimum Source Inlet Temperature + \type real + \units C + \required-field + \note Enter the minimum inlet outdoor air dry-bulb temperature + \note for air-cooled units or minimum inlet water temperature for water-cooled units. + \note The unit is disabled below this temperature. + N8, \field Maximum Source Inlet Temperature + \type real + \units C + \required-field + \note Enter the maximum inlet outdoor air dry-bulb temperature + \note for air-cooled units or maximum inlet water temperature for water-cooled units. + \note The unit is disabled above this temperature. + N9, \field Minimum Supply Water Temperature Curve Name + \type object-list + \object-list UnivariateFunctions + \note quadratic curve = a + b*OAT is typical, other univariate curves may be used + \note OAT = Outdoor Dry-Bulb Temperature + N10;\field Maximum Supply Water Temperature Curve Name + \type object-list + \object-list UnivariateFunctions + \note quadratic curve = a + b*OAT is typical, other univariate curves may be used + \note OAT = Outdoor Dry-Bulb Temperature OS:HeatPump:AirToWater:FuelFired:Heating, \memo The object defines a fuel-fired absorption heat pump based on equation-fit models. From ef83362391bff89e8082ac5ad0b9d5eed4b703f0 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 6 Sep 2023 12:50:33 -0700 Subject: [PATCH 02/18] Model files updates for cooling. --- src/model/HeatPumpPlantLoopEIRCooling.cpp | 136 ++++++++++++++++++ src/model/HeatPumpPlantLoopEIRCooling.hpp | 28 ++++ .../HeatPumpPlantLoopEIRCooling_Impl.hpp | 28 ++++ .../HeatPumpPlantLoopEIRCooling_GTest.cpp | 23 +++ 4 files changed, 215 insertions(+) diff --git a/src/model/HeatPumpPlantLoopEIRCooling.cpp b/src/model/HeatPumpPlantLoopEIRCooling.cpp index 17c331937a1..22fdb788481 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling.cpp +++ b/src/model/HeatPumpPlantLoopEIRCooling.cpp @@ -241,6 +241,44 @@ namespace model { return wo.optionalCast().get(); } + std::string HeatPumpPlantLoopEIRCooling_Impl::controlType() const { + boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_CoolingFields::ControlType, true); + OS_ASSERT(value); + return value.get(); + } + + std::string HeatPumpPlantLoopEIRCooling_Impl::flowMode() const { + boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, true); + OS_ASSERT(value); + return value.get(); + } + + double HeatPumpPlantLoopEIRCooling_Impl::minimumPartLoadRatio() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, true); + OS_ASSERT(value); + return value.get(); + } + + double HeatPumpPlantLoopEIRCooling_Impl::minimumSourceInletTemperature() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, true); + OS_ASSERT(value); + return value.get(); + } + + double HeatPumpPlantLoopEIRCooling_Impl::maximumSourceInletTemeperature() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, true); + OS_ASSERT(value); + return value.get(); + } + + boost::optional HeatPumpPlantLoopEIRCooling_Impl::minimumSupplyWaterTemperatureCurve() const { + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve); + } + + boost::optional HeatPumpPlantLoopEIRCooling_Impl::maximumSupplyWaterTemperatureCurve() const { + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve); + } + bool HeatPumpPlantLoopEIRCooling_Impl::setCompanionHeatingHeatPump(const HeatPumpPlantLoopEIRHeating& companionHP) { return this->setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::CompanionHeatPumpName, companionHP.handle()); } @@ -300,6 +338,38 @@ namespace model { return result; } + bool HeatPumpPlantLoopEIRCooling_Impl::setControlType(const std::string& controlType) { + bool result = setString(OS_HeatPump_PlantLoop_EIR_CoolingFields::ControlType, controlType); + return result; + } + + bool HeatPumpPlantLoopEIRCooling_Impl::setFlowMode(double flowMode) { + bool result = setString(OS_HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, flowMode); + return result; + } + + bool HeatPumpPlantLoopEIRCooling_Impl::setMinimumPartLoadRatio(double minimumPartLoadRatio) { + return setDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, minimumPartLoadRatio); + } + + bool HeatPumpPlantLoopEIRCooling_Impl::setMinimumSourceInletTemperature(double minimumSourceInletTemperature) { + return setDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, minimumSourceInletTemperature); + } + + bool HeatPumpPlantLoopEIRCooling_Impl::setMaximumSourceInletTemperature(double maximumSourceInletTemeperature) { + return setDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, maximumSourceInletTemeperature); + } + + bool HeatPumpPlantLoopEIRCooling_Impl::setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve) { + bool result = setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve, minimumSupplyWaterTemperatureCurve.handle()); + return result; + } + + bool HeatPumpPlantLoopEIRCooling_Impl::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { + bool result = setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve, maximumSupplyWaterTemperatureCurve.handle()); + return result; + } + boost::optional HeatPumpPlantLoopEIRCooling_Impl::autosizedLoadSideReferenceFlowRate() const { return getAutosizedValue("Design Size Load Side Volume Flow Rate", "m3/s"); } @@ -390,6 +460,11 @@ namespace model { setReferenceCoefficientofPerformance(7.5); // IDD default setSizingFactor(1.0); + setControlType("Load"); + setFlowMode("ConstantFlow"); + setMinimumPartLoadRatio(0.0); + setMinimumSourceInletTemperature(-100.0); + setMaximumSourceInletTemperature(100.0); } HeatPumpPlantLoopEIRCooling::HeatPumpPlantLoopEIRCooling(const Model& model) @@ -450,6 +525,11 @@ namespace model { setReferenceCoefficientofPerformance(7.5); setSizingFactor(1.0); + setControlType("Load"); + setFlowMode("ConstantFlow"); + setMinimumPartLoadRatio(0.0); + setMinimumSourceInletTemperature(-100.0); + setMaximumSourceInletTemperature(100.0); } IddObjectType HeatPumpPlantLoopEIRCooling::iddObjectType() { @@ -516,6 +596,34 @@ namespace model { return getImpl()->electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(); } + std::string HeatPumpPlantLoopEIRCooling::controlType() const { + return getImpl()->controlType(); + } + + std::string HeatPumpPlantLoopEIRCooling::flowMode() const { + return getImpl()->flowMode(); + } + + double HeatPumpPlantLoopEIRCooling::minimumPartLoadRatio() const { + return getImpl()->minimumPartLoadRatio(); + } + + double HeatPumpPlantLoopEIRCooling::minimumSourceInletTemperature() const { + return getImpl()->minimumSourceInletTemperature(); + } + + double HeatPumpPlantLoopEIRCooling::maximumSourceInletTemeperature() const { + return getImpl()->maximumSourceInletTemeperature(); + } + + boost::optional HeatPumpPlantLoopEIRCooling::minimumSupplyWaterTemperatureCurve() const { + return getImpl()->minimumSupplyWaterTemperatureCurve(); + } + + boost::optional HeatPumpPlantLoopEIRCooling::maximumSupplyWaterTemperatureCurve() const { + return getImpl()->maximumSupplyWaterTemperatureCurve(); + } + bool HeatPumpPlantLoopEIRCooling::setCondenserType(const std::string& condenserType) { return getImpl()->setCondenserType(condenserType); } @@ -573,6 +681,34 @@ namespace model { electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); } + bool HeatPumpPlantLoopEIRCooling::setControlType(const std::string& controlType) { + return getImpl()->setControlType(controlType); + } + + bool HeatPumpPlantLoopEIRCooling::setFlowMode(const std::string& flowMode) { + return getImpl()->setFlowMode(flowMode); + } + + bool HeatPumpPlantLoopEIRCooling::setMinimumPartLoadRatio(double minimumPartLoadRatio) { + return getImpl()->setMinimumPartLoadRatio(minimumPartLoadRatio); + } + + bool HeatPumpPlantLoopEIRCooling::setMinimumSourceInletTemperature(double minimumSourceInletTemperature) { + return getImpl()->setMinimumSourceInletTemperature(minimumSourceInletTemperature); + } + + bool HeatPumpPlantLoopEIRCooling::setMaximumSourceInletTemperature(double maximumSourceInletTemeperature) { + return getImpl()->setMaximumSourceInletTemperature(maximumSourceInletTemeperature); + } + + bool HeatPumpPlantLoopEIRCooling::setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve) { + return getImpl()->setMinimumSupplyWaterTemperatureCurve(minimumSupplyWaterTemperatureCurve); + } + + bool HeatPumpPlantLoopEIRCooling::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { + return getImpl()->setMaximumSupplyWaterTemperatureCurve(maximumSupplyWaterTemperatureCurve); + } + boost::optional HeatPumpPlantLoopEIRCooling::autosizedLoadSideReferenceFlowRate() const { return getImpl()->autosizedLoadSideReferenceFlowRate(); } diff --git a/src/model/HeatPumpPlantLoopEIRCooling.hpp b/src/model/HeatPumpPlantLoopEIRCooling.hpp index 0f48c71f087..b805b879ad5 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling.hpp +++ b/src/model/HeatPumpPlantLoopEIRCooling.hpp @@ -79,6 +79,20 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; + std::string controlType() const; + + std::string flowMode() const; + + double minimumPartLoadRatio() const; + + double minimumSourceInletTemperature() const; + + double maximumSourceInletTemeperature() const; + + boost::optional minimumSupplyWaterTemperatureCurve() const; + + boost::optional maximumSupplyWaterTemperatureCurve() const; + //@} /** @name Setters */ //@{ @@ -110,6 +124,20 @@ namespace model { bool setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(const Curve& electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); + bool setControlType(const std::string& controlType); + + bool setFlowMode(double flowMode); + + bool setMinimumPartLoadRatio(double minimumPartLoadRatio); + + bool setMinimumSourceInletTemperature(double minimumSourceInletTemperature); + + bool setMaximumSourceInletTemperature(double maximumSourceInletTemeperature); + + bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); + + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); + //@} /** @name Other */ //@{ diff --git a/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp b/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp index 728a7f7197b..f543a492ed5 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp +++ b/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp @@ -96,6 +96,20 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; + std::string controlType() const; + + std::string flowMode() const; + + double minimumPartLoadRatio() const; + + double minimumSourceInletTemperature() const; + + double maximumSourceInletTemeperature() const; + + boost::optional minimumSupplyWaterTemperatureCurve() const; + + boost::optional maximumSupplyWaterTemperatureCurve() const; + //@} /** @name Setters */ //@{ @@ -127,6 +141,20 @@ namespace model { bool setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve( const Curve& electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); + bool setControlType(const std::string& controlType); + + bool setFlowMode(double flowMode); + + bool setMinimumPartLoadRatio(double minimumPartLoadRatio); + + bool setMinimumSourceInletTemperature(double minimumSourceInletTemperature); + + bool setMaximumSourceInletTemperature(double maximumSourceInletTemeperature); + + bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); + + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); + //@} /** @name Other */ //@{ diff --git a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp index e128aea37f4..ecb2c959624 100644 --- a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp @@ -59,6 +59,13 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_HeatPumpPlantLoopEIRCooling) { boost::optional electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve = hp.electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(); EXPECT_TRUE(electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); + EXPECT_EQ("Load", hp.controlType()); + EXPECT_EQ("ConstantFlow", hp.flowMode()); + EXPECT_EQ(0.0, hp.minimumPartLoadRatio()); + EXPECT_EQ(-100.0, hp.minimumSourceInletTemperature()); + EXPECT_EQ(100.0, hp.maximumSourceInletTemeperature()); + EXPECT_FALSE(hp.minimumSupplyWaterTemperatureCurve()); + EXPECT_FALSE(hp.maximumSupplyWaterTemperatureCurve()); } TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_GettersSetters) { @@ -79,6 +86,15 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_GettersSetters) { EXPECT_TRUE(hp.setElectricInputtoOutputRatioModifierFunctionofTemperatureCurve(curve2)); CurveQuadratic curve3(m); EXPECT_TRUE(hp.setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(curve3)); + EXPECT_TRUE(hp.setControlType("Setpoint")); + EXPECT_TRUE(hp.setFlowMode("VariableSpeedPumping")); + EXPECT_TRUE(hp.setMinimumPartLoadRatio(1)); + EXPECT_TRUE(hp.setMinimumSourceInletTemperature(2)); + EXPECT_TRUE(hp.setMaximumSourceInletTemperature(3)); + CurveQuadratic curve4(m); + EXPECT_TRUE(hp.setMinimumSupplyWaterTemperatureCurve(curve4)); + CurveQuadratic curve5(m); + EXPECT_TRUE(hp.setMaximumSupplyWaterTemperatureCurve(curve5)); EXPECT_EQ("AirSource", hp.condenserType()); ASSERT_TRUE(hp.companionHeatingHeatPump()); @@ -97,6 +113,13 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_GettersSetters) { EXPECT_EQ(curve1.handle(), hp.capacityModifierFunctionofTemperatureCurve().handle()); EXPECT_EQ(curve2.handle(), hp.electricInputtoOutputRatioModifierFunctionofTemperatureCurve().handle()); EXPECT_EQ(curve3.handle(), hp.electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve().handle()); + EXPECT_EQ("Setpoint", hp.controlType()); + EXPECT_EQ("VariableSpeedPumping", hp.flowMode()); + EXPECT_EQ(1, hp.minimumPartLoadRatio()); + EXPECT_EQ(2, hp.minimumSourceInletTemperature()); + EXPECT_EQ(3, hp.maximumSourceInletTemeperature()); + EXPECT_EQ(curve4.handle(), hp.minimumSupplyWaterTemperatureCurve().handle()); + EXPECT_EQ(curve5.handle(), hp.maximumSupplyWaterTemperatureCurve().handle()); hp.autosizeLoadSideReferenceFlowRate(); EXPECT_TRUE(hp.isLoadSideReferenceFlowRateAutosized()); From 52a2d1c50ace49168db844d81e1a7687d5a9cdb4 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 6 Sep 2023 12:50:43 -0700 Subject: [PATCH 03/18] FT file updates for cooling. --- ...rdTranslateHeatPumpPlantLoopEIRCooling.cpp | 22 +++++++++++++++++++ .../Test/HeatPumpPlantLoopEIR_GTest.cpp | 18 +++++++++++++++ 2 files changed, 40 insertions(+) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp index 4b71bfd3ef0..44d45f5599e 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp @@ -139,6 +139,28 @@ namespace energyplus { } } + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::ControlType, modelObject.controlType()); + + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, modelObject.flowMode()); + + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, modelObject.minimumPartLoadRatio()); + + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, modelObject.minimumSourceInletTemperature()); + + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, modelObject.maximumSourceInletTemeperature()); + + if (boost::optional curve = modelObject.minimumSupplyWaterTemperatureCurve()) { + if (boost::optional _curve = translateAndMapModelObject(curve.get())) { + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve, _curve->name().get()); + } + } + + if (boost::optional curve = modelObject.maximumSupplyWaterTemperatureCurve()) { + if (boost::optional _curve = translateAndMapModelObject(curve.get())) { + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve, _curve->name().get()); + } + } + return idfObject; } diff --git a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp index 1d0d92f5d19..f63a0655361 100644 --- a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp +++ b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp @@ -49,6 +49,15 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { EXPECT_TRUE(plhp_clg.setElectricInputtoOutputRatioModifierFunctionofTemperatureCurve(curve2)); CurveQuadratic curve3(m); EXPECT_TRUE(plhp_clg.setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(curve3)); + EXPECT_TRUE(plhp_clg.setControlType("Setpoint")); + EXPECT_TRUE(plhp_clg.setFlowMode("VariableSpeedPumping")); + EXPECT_TRUE(plhp_clg.setMinimumPartLoadRatio(6.0)); + EXPECT_TRUE(plhp_clg.setMinimumSourceInletTemperature(7.0)); + EXPECT_TRUE(plhp_clg.setMaximumSourceInletTemperature(8.0)); + CurveQuadratic curve4(m); + EXPECT_TRUE(plhp_clg.setMinimumSupplyWaterTemperatureCurve(curve4)); + CurveQuadratic curve5(m); + EXPECT_TRUE(plhp_clg.setMaximumSupplyWaterTemperatureCurve(curve5)); HeatPumpPlantLoopEIRHeating plhp_htg(m); EXPECT_TRUE(plhp_htg.setLoadSideReferenceFlowRate(1.0)); @@ -107,6 +116,15 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { idf_cc.getTarget(HeatPump_PlantLoop_EIR_CoolingFields::ElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurveName)); EXPECT_TRUE(woCurve3); EXPECT_EQ(woCurve3->iddObject().type(), IddObjectType::Curve_Quadratic); + EXPECT_EQ("Setpoint", idf_cc.getString(HeatPump_PlantLoop_EIR_CoolingFields::ControlType, false).get()); + EXPECT_EQ("VariableSpeedPumping", idf_cc.getString(HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, false).get()); + EXPECT_EQ(6.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, false).get()); + EXPECT_EQ(7.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, false).get()); + EXPECT_EQ(8.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, false).get()); + boost::optional woCurve4(idf_cc.getTarget(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve)); + EXPECT_TRUE(woCurve4); + boost::optional woCurve5(idf_cc.getTarget(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve)); + EXPECT_TRUE(woCurve5); } { From e1e9fa328adf9c2b6e769b31f961eb929a8aa9d6 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 6 Sep 2023 12:50:59 -0700 Subject: [PATCH 04/18] Formatting. --- ...rdTranslateHeatPumpPlantLoopEIRCooling.cpp | 8 +-- src/model/HeatPumpPlantLoopEIRCooling.cpp | 56 ++++++++++--------- src/model/HeatPumpPlantLoopEIRCooling.hpp | 24 ++++---- .../HeatPumpPlantLoopEIRCooling_Impl.hpp | 24 ++++---- 4 files changed, 57 insertions(+), 55 deletions(-) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp index 44d45f5599e..40b9002b115 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp @@ -140,13 +140,13 @@ namespace energyplus { } idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::ControlType, modelObject.controlType()); - + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, modelObject.flowMode()); - + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, modelObject.minimumPartLoadRatio()); - + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, modelObject.minimumSourceInletTemperature()); - + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, modelObject.maximumSourceInletTemeperature()); if (boost::optional curve = modelObject.minimumSupplyWaterTemperatureCurve()) { diff --git a/src/model/HeatPumpPlantLoopEIRCooling.cpp b/src/model/HeatPumpPlantLoopEIRCooling.cpp index 22fdb788481..cd196ed518b 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling.cpp +++ b/src/model/HeatPumpPlantLoopEIRCooling.cpp @@ -246,35 +246,35 @@ namespace model { OS_ASSERT(value); return value.get(); } - + std::string HeatPumpPlantLoopEIRCooling_Impl::flowMode() const { boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, true); OS_ASSERT(value); return value.get(); } - + double HeatPumpPlantLoopEIRCooling_Impl::minimumPartLoadRatio() const { boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, true); OS_ASSERT(value); - return value.get(); + return value.get(); } - + double HeatPumpPlantLoopEIRCooling_Impl::minimumSourceInletTemperature() const { boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, true); OS_ASSERT(value); return value.get(); } - + double HeatPumpPlantLoopEIRCooling_Impl::maximumSourceInletTemeperature() const { boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, true); OS_ASSERT(value); return value.get(); } - + boost::optional HeatPumpPlantLoopEIRCooling_Impl::minimumSupplyWaterTemperatureCurve() const { return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve); } - + boost::optional HeatPumpPlantLoopEIRCooling_Impl::maximumSupplyWaterTemperatureCurve() const { return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve); } @@ -342,31 +342,33 @@ namespace model { bool result = setString(OS_HeatPump_PlantLoop_EIR_CoolingFields::ControlType, controlType); return result; } - + bool HeatPumpPlantLoopEIRCooling_Impl::setFlowMode(double flowMode) { bool result = setString(OS_HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, flowMode); return result; } - + bool HeatPumpPlantLoopEIRCooling_Impl::setMinimumPartLoadRatio(double minimumPartLoadRatio) { return setDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, minimumPartLoadRatio); } - + bool HeatPumpPlantLoopEIRCooling_Impl::setMinimumSourceInletTemperature(double minimumSourceInletTemperature) { return setDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, minimumSourceInletTemperature); } - + bool HeatPumpPlantLoopEIRCooling_Impl::setMaximumSourceInletTemperature(double maximumSourceInletTemeperature) { return setDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, maximumSourceInletTemeperature); } - + bool HeatPumpPlantLoopEIRCooling_Impl::setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve) { - bool result = setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve, minimumSupplyWaterTemperatureCurve.handle()); + bool result = + setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve, minimumSupplyWaterTemperatureCurve.handle()); return result; } - + bool HeatPumpPlantLoopEIRCooling_Impl::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { - bool result = setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve, maximumSupplyWaterTemperatureCurve.handle()); + bool result = + setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve, maximumSupplyWaterTemperatureCurve.handle()); return result; } @@ -599,27 +601,27 @@ namespace model { std::string HeatPumpPlantLoopEIRCooling::controlType() const { return getImpl()->controlType(); } - + std::string HeatPumpPlantLoopEIRCooling::flowMode() const { return getImpl()->flowMode(); } - + double HeatPumpPlantLoopEIRCooling::minimumPartLoadRatio() const { return getImpl()->minimumPartLoadRatio(); } - + double HeatPumpPlantLoopEIRCooling::minimumSourceInletTemperature() const { return getImpl()->minimumSourceInletTemperature(); } - + double HeatPumpPlantLoopEIRCooling::maximumSourceInletTemeperature() const { return getImpl()->maximumSourceInletTemeperature(); } - + boost::optional HeatPumpPlantLoopEIRCooling::minimumSupplyWaterTemperatureCurve() const { return getImpl()->minimumSupplyWaterTemperatureCurve(); } - + boost::optional HeatPumpPlantLoopEIRCooling::maximumSupplyWaterTemperatureCurve() const { return getImpl()->maximumSupplyWaterTemperatureCurve(); } @@ -684,27 +686,27 @@ namespace model { bool HeatPumpPlantLoopEIRCooling::setControlType(const std::string& controlType) { return getImpl()->setControlType(controlType); } - + bool HeatPumpPlantLoopEIRCooling::setFlowMode(const std::string& flowMode) { return getImpl()->setFlowMode(flowMode); } - + bool HeatPumpPlantLoopEIRCooling::setMinimumPartLoadRatio(double minimumPartLoadRatio) { return getImpl()->setMinimumPartLoadRatio(minimumPartLoadRatio); } - + bool HeatPumpPlantLoopEIRCooling::setMinimumSourceInletTemperature(double minimumSourceInletTemperature) { return getImpl()->setMinimumSourceInletTemperature(minimumSourceInletTemperature); } - + bool HeatPumpPlantLoopEIRCooling::setMaximumSourceInletTemperature(double maximumSourceInletTemeperature) { return getImpl()->setMaximumSourceInletTemperature(maximumSourceInletTemeperature); } - + bool HeatPumpPlantLoopEIRCooling::setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve) { return getImpl()->setMinimumSupplyWaterTemperatureCurve(minimumSupplyWaterTemperatureCurve); } - + bool HeatPumpPlantLoopEIRCooling::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { return getImpl()->setMaximumSupplyWaterTemperatureCurve(maximumSupplyWaterTemperatureCurve); } diff --git a/src/model/HeatPumpPlantLoopEIRCooling.hpp b/src/model/HeatPumpPlantLoopEIRCooling.hpp index b805b879ad5..6e0a669658a 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling.hpp +++ b/src/model/HeatPumpPlantLoopEIRCooling.hpp @@ -80,17 +80,17 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; std::string controlType() const; - + std::string flowMode() const; - + double minimumPartLoadRatio() const; - + double minimumSourceInletTemperature() const; - + double maximumSourceInletTemeperature() const; - + boost::optional minimumSupplyWaterTemperatureCurve() const; - + boost::optional maximumSupplyWaterTemperatureCurve() const; //@} @@ -125,17 +125,17 @@ namespace model { setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(const Curve& electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); bool setControlType(const std::string& controlType); - + bool setFlowMode(double flowMode); - + bool setMinimumPartLoadRatio(double minimumPartLoadRatio); - + bool setMinimumSourceInletTemperature(double minimumSourceInletTemperature); - + bool setMaximumSourceInletTemperature(double maximumSourceInletTemeperature); - + bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); - + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); //@} diff --git a/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp b/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp index f543a492ed5..8005602dc52 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp +++ b/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp @@ -97,17 +97,17 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; std::string controlType() const; - + std::string flowMode() const; - + double minimumPartLoadRatio() const; - + double minimumSourceInletTemperature() const; - + double maximumSourceInletTemeperature() const; - + boost::optional minimumSupplyWaterTemperatureCurve() const; - + boost::optional maximumSupplyWaterTemperatureCurve() const; //@} @@ -142,17 +142,17 @@ namespace model { const Curve& electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); bool setControlType(const std::string& controlType); - + bool setFlowMode(double flowMode); - + bool setMinimumPartLoadRatio(double minimumPartLoadRatio); - + bool setMinimumSourceInletTemperature(double minimumSourceInletTemperature); - + bool setMaximumSourceInletTemperature(double maximumSourceInletTemeperature); - + bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); - + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); //@} From 2568c1f7e0d5fd7334b74cb3d2d17e152fc7e768 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 6 Sep 2023 15:39:50 -0700 Subject: [PATCH 05/18] Typos in source files. --- src/model/HeatPumpPlantLoopEIRCooling.cpp | 20 +++++++++---------- src/model/HeatPumpPlantLoopEIRCooling.hpp | 6 +++--- .../HeatPumpPlantLoopEIRCooling_Impl.hpp | 6 +++--- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/model/HeatPumpPlantLoopEIRCooling.cpp b/src/model/HeatPumpPlantLoopEIRCooling.cpp index cd196ed518b..f83b5c1a67f 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling.cpp +++ b/src/model/HeatPumpPlantLoopEIRCooling.cpp @@ -248,7 +248,7 @@ namespace model { } std::string HeatPumpPlantLoopEIRCooling_Impl::flowMode() const { - boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, true); + boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, true); OS_ASSERT(value); return value.get(); } @@ -265,8 +265,8 @@ namespace model { return value.get(); } - double HeatPumpPlantLoopEIRCooling_Impl::maximumSourceInletTemeperature() const { - boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, true); + double HeatPumpPlantLoopEIRCooling_Impl::maximumSourceInletTemperature() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemperature, true); OS_ASSERT(value); return value.get(); } @@ -343,7 +343,7 @@ namespace model { return result; } - bool HeatPumpPlantLoopEIRCooling_Impl::setFlowMode(double flowMode) { + bool HeatPumpPlantLoopEIRCooling_Impl::setFlowMode(const std::string& flowMode) { bool result = setString(OS_HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, flowMode); return result; } @@ -356,8 +356,8 @@ namespace model { return setDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, minimumSourceInletTemperature); } - bool HeatPumpPlantLoopEIRCooling_Impl::setMaximumSourceInletTemperature(double maximumSourceInletTemeperature) { - return setDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, maximumSourceInletTemeperature); + bool HeatPumpPlantLoopEIRCooling_Impl::setMaximumSourceInletTemperature(double maximumSourceInletTemperature) { + return setDouble(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemperature, maximumSourceInletTemperature); } bool HeatPumpPlantLoopEIRCooling_Impl::setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve) { @@ -614,8 +614,8 @@ namespace model { return getImpl()->minimumSourceInletTemperature(); } - double HeatPumpPlantLoopEIRCooling::maximumSourceInletTemeperature() const { - return getImpl()->maximumSourceInletTemeperature(); + double HeatPumpPlantLoopEIRCooling::maximumSourceInletTemperature() const { + return getImpl()->maximumSourceInletTemperature(); } boost::optional HeatPumpPlantLoopEIRCooling::minimumSupplyWaterTemperatureCurve() const { @@ -699,8 +699,8 @@ namespace model { return getImpl()->setMinimumSourceInletTemperature(minimumSourceInletTemperature); } - bool HeatPumpPlantLoopEIRCooling::setMaximumSourceInletTemperature(double maximumSourceInletTemeperature) { - return getImpl()->setMaximumSourceInletTemperature(maximumSourceInletTemeperature); + bool HeatPumpPlantLoopEIRCooling::setMaximumSourceInletTemperature(double maximumSourceInletTemperature) { + return getImpl()->setMaximumSourceInletTemperature(maximumSourceInletTemperature); } bool HeatPumpPlantLoopEIRCooling::setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve) { diff --git a/src/model/HeatPumpPlantLoopEIRCooling.hpp b/src/model/HeatPumpPlantLoopEIRCooling.hpp index 6e0a669658a..b7784a1cfde 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling.hpp +++ b/src/model/HeatPumpPlantLoopEIRCooling.hpp @@ -87,7 +87,7 @@ namespace model { double minimumSourceInletTemperature() const; - double maximumSourceInletTemeperature() const; + double maximumSourceInletTemperature() const; boost::optional minimumSupplyWaterTemperatureCurve() const; @@ -126,13 +126,13 @@ namespace model { bool setControlType(const std::string& controlType); - bool setFlowMode(double flowMode); + bool setFlowMode(const std::string& flowMode); bool setMinimumPartLoadRatio(double minimumPartLoadRatio); bool setMinimumSourceInletTemperature(double minimumSourceInletTemperature); - bool setMaximumSourceInletTemperature(double maximumSourceInletTemeperature); + bool setMaximumSourceInletTemperature(double maximumSourceInletTemperature); bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); diff --git a/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp b/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp index 8005602dc52..7f91f3e6b76 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp +++ b/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp @@ -104,7 +104,7 @@ namespace model { double minimumSourceInletTemperature() const; - double maximumSourceInletTemeperature() const; + double maximumSourceInletTemperature() const; boost::optional minimumSupplyWaterTemperatureCurve() const; @@ -143,13 +143,13 @@ namespace model { bool setControlType(const std::string& controlType); - bool setFlowMode(double flowMode); + bool setFlowMode(const std::string& flowMode); bool setMinimumPartLoadRatio(double minimumPartLoadRatio); bool setMinimumSourceInletTemperature(double minimumSourceInletTemperature); - bool setMaximumSourceInletTemperature(double maximumSourceInletTemeperature); + bool setMaximumSourceInletTemperature(double maximumSourceInletTemperature); bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); From f17031cbc66b81154a74f8f96b1e3e58dccf2a30 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 6 Sep 2023 16:18:14 -0700 Subject: [PATCH 06/18] Fix curve field names. --- .../ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp | 4 ++-- src/model/HeatPumpPlantLoopEIRCooling.cpp | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp index 40b9002b115..65ad8fa327a 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp @@ -151,13 +151,13 @@ namespace energyplus { if (boost::optional curve = modelObject.minimumSupplyWaterTemperatureCurve()) { if (boost::optional _curve = translateAndMapModelObject(curve.get())) { - idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve, _curve->name().get()); + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurveName, _curve->name().get()); } } if (boost::optional curve = modelObject.maximumSupplyWaterTemperatureCurve()) { if (boost::optional _curve = translateAndMapModelObject(curve.get())) { - idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve, _curve->name().get()); + idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurveName, _curve->name().get()); } } diff --git a/src/model/HeatPumpPlantLoopEIRCooling.cpp b/src/model/HeatPumpPlantLoopEIRCooling.cpp index f83b5c1a67f..dfd901a4eac 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling.cpp +++ b/src/model/HeatPumpPlantLoopEIRCooling.cpp @@ -272,11 +272,11 @@ namespace model { } boost::optional HeatPumpPlantLoopEIRCooling_Impl::minimumSupplyWaterTemperatureCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve); + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurveName); } boost::optional HeatPumpPlantLoopEIRCooling_Impl::maximumSupplyWaterTemperatureCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve); + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurveName); } bool HeatPumpPlantLoopEIRCooling_Impl::setCompanionHeatingHeatPump(const HeatPumpPlantLoopEIRHeating& companionHP) { @@ -362,13 +362,13 @@ namespace model { bool HeatPumpPlantLoopEIRCooling_Impl::setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve) { bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve, minimumSupplyWaterTemperatureCurve.handle()); + setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurveName, minimumSupplyWaterTemperatureCurve.handle()); return result; } bool HeatPumpPlantLoopEIRCooling_Impl::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve, maximumSupplyWaterTemperatureCurve.handle()); + setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurveName, maximumSupplyWaterTemperatureCurve.handle()); return result; } From 01cec23e1b5a2a325c6e13106abf181f7c310320 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 7 Sep 2023 09:35:51 -0700 Subject: [PATCH 07/18] Add heating idd and model file changes. --- resources/energyplus/ProposedEnergy+.idd | 12 +- resources/model/OpenStudio.idd | 111 +++++++ ...rdTranslateHeatPumpPlantLoopEIRCooling.cpp | 6 +- src/model/HeatPumpPlantLoopEIRHeating.cpp | 310 ++++++++++++++++++ src/model/HeatPumpPlantLoopEIRHeating.hpp | 68 ++++ .../HeatPumpPlantLoopEIRHeating_Impl.hpp | 68 ++++ 6 files changed, 566 insertions(+), 9 deletions(-) diff --git a/resources/energyplus/ProposedEnergy+.idd b/resources/energyplus/ProposedEnergy+.idd index 961877f9e97..0f07725595a 100644 --- a/resources/energyplus/ProposedEnergy+.idd +++ b/resources/energyplus/ProposedEnergy+.idd @@ -45029,17 +45029,17 @@ HeatPump:PlantLoop:EIR:Heating, \note The unit is disabled above this temperature. A14, \field Minimum Supply Water Temperature Curve Name \type object-list - \object-list UniVariateFunctions + \object-list UnivariateFunctions \note quadratic curve = a + b*OAT is typical, other univariate curves may be used \note OAT = Outdoor Dry-Bulb Temperature A15, \field Maximum Supply Water Temperature Curve Name \type object-list - \object-list UniVariateFunctions + \object-list UnivariateFunctions \note quadratic curve = a + b*OAT is typical, other univariate curves may be used \note OAT = Outdoor Dry-Bulb Temperature A16, \field Dry Outdoor Correction Factor Curve Name \type object-list - \object-list UniVariateFunctions + \object-list UnivariateFunctions N10, \field Maximum Outdoor Dry Bulb Temperature For Defrost Operation \type real \default 10.0 @@ -45067,14 +45067,14 @@ HeatPump:PlantLoop:EIR:Heating, \note only required if Timed or OnDemand defrost strategy is specified A19, \field Timed Empirical Defrost Frequency Curve Name \type object-list - \object-list UniVariateFunctions + \object-list UnivariateFunctions \note univariate curve = a + b*OAT is typical, other univariate curves may be used \note OAT = outdoor air dry-bulb temperature (C) \note Timed Empirical Defrost Frequency fraction in hours = curve output \note only applicable if TimedEmpirical defrost control is specified A20, \field Timed Empirical Defrost Heat Load Penalty Curve Name \type object-list - \object-list UniVariateFunctions + \object-list UnivariateFunctions \object-list BivariateFunctions \note univariate curve = a + b*OAT is typical, other univariate curves may be used \note bivariate curve = a + b*WB + c*WB**2 + d*OAT + e*OAT**2 + f*WB*OAT @@ -45084,7 +45084,7 @@ HeatPump:PlantLoop:EIR:Heating, \note only applicable if TimedEmpirical defrost control is specified A21; \field Timed Empirical Defrost Heat Input Energy Fraction Curve Name \type object-list - \object-list UniVariateFunctions + \object-list UnivariateFunctions \object-list BivariateFunctions \note univariate curve = a + b*OAT is typical, other univariate curves may be used \note bivariate curve = a + b*WB + c*WB**2 + d*OAT + e*OAT**2 + f*WB*OAT diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index 5b73f9aa35a..bf58af890f9 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -14063,6 +14063,117 @@ OS:HeatPump:PlantLoop:EIR:Heating, \object-list UnivariateFunctions \note quadratic curve = a + b*PLR + c*PLR**2 is typical, other univariate curves may be used \note PLR = part load ratio (hot load/steady state capacity) + N6, \field Heating To Cooling Capacity Sizing Ratio + \note Multiplies the autosized heating capacity + \type real + \minimum 0.0 + \required-field + A12,\field Heat Pump Sizing Method + \note Specifies sizing method when companion coil exists + \type choice + \key CoolingCapacity + \key HeatingCapacity + \key GreaterOfHeatingOrCooling + \required-field + A13,\field Control Type + \note Heat pump can be controlled on leaving water temperature set point or plant load + \type choice + \key Setpoint + \key Load + \required-field + A14,\field Flow Mode + \note Select operating mode for fluid flow through the chiller. "ConstantFlow" is for + \note constant pumping with flow controlled by chiller to operate at full design + \note flow rate. "VariableSpeedPumping" is for variable pumping with flow proportional + \note to chiller operating part load ratio. + \type choice + \key ConstantFlow + \key VariableSpeedPumping + \required-field + N7, \field Minimum Part Load Ratio + \note Below this operating limit compressor cycling will occur + \type real + \minimum 0.0 + \required-field + N8, \field Minimum Source Inlet Temperature + \type real + \units C + \required-field + \note Enter the minimum inlet outdoor air dry-bulb temperature + \note for air-cooled units or minimum inlet water temperature for water-cooled units. + \note The unit is disabled below this temperature. + N9, \field Maximum Source Inlet Temperature + \type real + \units C + \required-field + \note Enter the maximum inlet outdoor air dry-bulb temperature + \note for air-cooled units or maximum inlet water temperature for water-cooled units. + \note The unit is disabled above this temperature. + A15,\field Minimum Supply Water Temperature Curve Name + \type object-list + \object-list UnivariateFunctions + \note quadratic curve = a + b*OAT is typical, other univariate curves may be used + \note OAT = Outdoor Dry-Bulb Temperature + A16,\field Maximum Supply Water Temperature Curve Name + \type object-list + \object-list UnivariateFunctions + \note quadratic curve = a + b*OAT is typical, other univariate curves may be used + \note OAT = Outdoor Dry-Bulb Temperature + A17,\field Dry Outdoor Correction Factor Curve Name + \type object-list + \object-list UnivariateFunctions + N10,\field Maximum Outdoor Dry Bulb Temperature For Defrost Operation + \type real + \required-field + \note defrost operation will not be active above this outdoor temperature + A18,\field Heat Pump Defrost Control + \type choice + \key None + \key Timed + \key OnDemand + \key TimedEmpirical + \required-field + N11,\field Heat Pump Defrost Time Period Fraction + \type real + \minimum 0.0 + \required-field + \note Nominal fraction of time in defrost mode + \note only applicable if Timed or TimedEmpirical heat pump defrost control is specified + A19,\field Defrost Energy Input Ratio Function of Temperature Curve Name + \type object-list + \object-list BivariateFunctions + \note univariate curve = a + b*OAT is typical, other univariate curves may be used + \note bivariate curve = a + b*WB + c*WB**2 + d*OAT + e*OAT**2 + f*WB*OAT + \note OAT = outdoor air dry-bulb temperature (C) + \note WB = wet-bulb temperature (C) of air entering the indoor coil + \note only required if Timed or OnDemand defrost strategy is specified + A20,\field Timed Empirical Defrost Frequency Curve Name + \type object-list + \object-list UnivariateFunctions + \note univariate curve = a + b*OAT is typical, other univariate curves may be used + \note OAT = outdoor air dry-bulb temperature (C) + \note Timed Empirical Defrost Frequency fraction in hours = curve output + \note only applicable if TimedEmpirical defrost control is specified + A21,\field Timed Empirical Defrost Heat Load Penalty Curve Name + \type object-list + \object-list UnivariateFunctions + \object-list BivariateFunctions + \note univariate curve = a + b*OAT is typical, other univariate curves may be used + \note bivariate curve = a + b*WB + c*WB**2 + d*OAT + e*OAT**2 + f*WB*OAT + \note OAT = outdoor air dry-bulb temperature (C) + \note WB = wet-bulb temperature (C) of air entering the indoor coil + \note Timed Empirical Defrost Heat Load Penalty in watts = hot load * curve output + \note only applicable if TimedEmpirical defrost control is specified + A22;\field Timed Empirical Defrost Heat Input Energy Fraction Curve Name + \type object-list + \object-list UnivariateFunctions + \object-list BivariateFunctions + \note univariate curve = a + b*OAT is typical, other univariate curves may be used + \note bivariate curve = a + b*WB + c*WB**2 + d*OAT + e*OAT**2 + f*WB*OAT + \note OAT = outdoor air dry-bulb temperature (C) + \note WB = wet-bulb temperature (C) of air entering the indoor coil + \note Timed Empirical Defrost Heat Input Energy in watts = rated hot load * curve output + \note only applicable if TimedEmpirical defrost control is specified OS:HeatPump:PlantLoop:EIR:Cooling, \memo An EIR formulated water to water heat pump model, cooling operation. diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp index 65ad8fa327a..4da9be9e6b7 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp @@ -143,11 +143,11 @@ namespace energyplus { idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, modelObject.flowMode()); - idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, modelObject.minimumPartLoadRatio()); + idfObject.setDouble(HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, modelObject.minimumPartLoadRatio()); - idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, modelObject.minimumSourceInletTemperature()); + idfObject.setDouble(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, modelObject.minimumSourceInletTemperature()); - idfObject.setString(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, modelObject.maximumSourceInletTemeperature()); + idfObject.setDouble(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemperature, modelObject.maximumSourceInletTemperature()); if (boost::optional curve = modelObject.minimumSupplyWaterTemperatureCurve()) { if (boost::optional _curve = translateAndMapModelObject(curve.get())) { diff --git a/src/model/HeatPumpPlantLoopEIRHeating.cpp b/src/model/HeatPumpPlantLoopEIRHeating.cpp index 35925c66fbb..25419bfe82b 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.cpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.cpp @@ -242,6 +242,94 @@ namespace model { return wo.optionalCast().get(); } + double HeatPumpPlantLoopEIRHeating_Impl::heatingtoCoolingCapacitySizingRatio() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatingtoCoolingCapacitySizingRatio, true); + OS_ASSERT(value); + return value.get(); + } + + std::string HeatPumpPlantLoopEIRHeating_Impl::heatPumpSizingMethod() const { + boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpSizingMethod, true); + OS_ASSERT(value); + return value.get(); + } + + std::string HeatPumpPlantLoopEIRHeating_Impl::controlType() const { + boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_HeatingFields::ControlType, true); + OS_ASSERT(value); + return value.get(); + } + + std::string HeatPumpPlantLoopEIRHeating_Impl::flowMode() const { + boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_HeatingFields::FlowMode, true); + OS_ASSERT(value); + return value.get(); + } + + double HeatPumpPlantLoopEIRHeating_Impl::minimumPartLoadRatio() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MinimumPartLoadRatio, true); + OS_ASSERT(value); + return value.get(); + } + + double HeatPumpPlantLoopEIRHeating_Impl::minimumSourceInletTemperature() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MinimumSourceInletTemperature, true); + OS_ASSERT(value); + return value.get(); + } + + double HeatPumpPlantLoopEIRHeating_Impl::maximumSourceInletTemperature() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumSourceInletTemperature, true); + OS_ASSERT(value); + return value.get(); + } + + boost::optional HeatPumpPlantLoopEIRHeating_Impl::minimumSupplyWaterTemperatureCurve() const { + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::MinimumSupplyWaterTemperatureCurveName); + } + + boost::optional HeatPumpPlantLoopEIRHeating_Impl::maximumSupplyWaterTemperatureCurve() const { + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumSupplyWaterTemperatureCurveName); + } + + boost::optional HeatPumpPlantLoopEIRHeating_Impl::dryOutdoorCorrectionFactorCurve() const { + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurve); + } + + double HeatPumpPlantLoopEIRHeating_Impl::maximumOutdoorDryBulbTemperatureForDefrostOperation() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, true); + OS_ASSERT(value); + return value.get(); + } + + std::string HeatPumpPlantLoopEIRHeating_Impl::heatPumpDefrostControl() const { + boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostControl, true); + OS_ASSERT(value); + return value.get(); + } + + double HeatPumpPlantLoopEIRHeating_Impl::heatPumpDefrostTimePeriodFraction() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostTimePeriodFraction, true); + OS_ASSERT(value); + return value.get(); + } + + boost::optional HeatPumpPlantLoopEIRHeating_Impl::defrostEnergyInputRatioFunctionofTemperatureCurve() const { + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurve); + } + + boost::optional HeatPumpPlantLoopEIRHeating_Impl::timedEmpiricalDefrostFrequencyCurve() const { + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurve); + } + + boost::optional HeatPumpPlantLoopEIRHeating_Impl::timedEmpiricalDefrostHeatLoadPenaltyCurve() const { + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurve); + } + + boost::optional HeatPumpPlantLoopEIRHeating_Impl::timedEmpiricalDefrostHeatInputEnergyFractionCurve() const { + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurve); + } + bool HeatPumpPlantLoopEIRHeating_Impl::setCompanionCoolingHeatPump(const HeatPumpPlantLoopEIRCooling& companionHP) { return this->setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::CompanionHeatPumpName, companionHP.handle()); } @@ -301,6 +389,92 @@ namespace model { return result; } + bool HeatPumpPlantLoopEIRHeating_Impl::setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio) { + return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatingtoCoolingCapacitySizingRatio, heatingtoCoolingCapacitySizingRatio); + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod) { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpSizingMethod, heatPumpSizingMethod); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setControlType(const std::string& controlType) { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::ControlType, controlType); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setFlowMode(const std::string& flowMode) { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::FlowMode, flowMode); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setMinimumPartLoadRatio(double minimumPartLoadRatio) { + return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MinimumPartLoadRatio, minimumPartLoadRatio); + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setMinimumSourceInletTemperature(double minimumSourceInletTemperature) { + return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MinimumSourceInletTemperature, minimumSourceInletTemperature); + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setMaximumSourceInletTemperature(double maximumSourceInletTemperature) { + return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumSourceInletTemperature, maximumSourceInletTemperature); + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve) { + bool result = + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::MinimumSupplyWaterTemperatureCurveName, minimumSupplyWaterTemperatureCurve.handle()); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { + bool result = + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumSupplyWaterTemperatureCurveName, maximumSupplyWaterTemperatureCurve.handle()); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve) { + bool result = + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurve, dryOutdoorCorrectionFactorCurve.handle()); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation) { + return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, maximumOutdoorDryBulbTemperatureForDefrostOperation); + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl) { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostControl, heatPumpDefrostControl); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setHeatPumpDefrostTimePeriodFraction(double heatPumpDefrostTimePeriodFraction) { + return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostTimePeriodFraction, heatPumpDefrostTimePeriodFraction); + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve) { + bool result = + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurve, defrostEnergyInputRatioFunctionofTemperatureCurve.handle()); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve) { + bool result = + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurve, timedEmpiricalDefrostFrequencyCurve.handle()); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve) { + bool result = + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurve, timedEmpiricalDefrostHeatLoadPenaltyCurve.handle()); + return result; + } + + bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve) { + bool result = + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurve, timedEmpiricalDefrostHeatInputEnergyFractionCurve.handle()); + return result; + } + boost::optional HeatPumpPlantLoopEIRHeating_Impl::autosizedLoadSideReferenceFlowRate() const { return getAutosizedValue("Design Size Load Side Volume Flow Rate", "m3/s"); } @@ -517,6 +691,74 @@ namespace model { return getImpl()->electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(); } + double HeatPumpPlantLoopEIRHeating::heatingtoCoolingCapacitySizingRatio() const { + return getImpl()->heatingtoCoolingCapacitySizingRatio(); + } + + std::string HeatPumpPlantLoopEIRHeating::heatPumpSizingMethod() const { + return getImpl()->heatPumpSizingMethod(); + } + + std::string HeatPumpPlantLoopEIRHeating::controlType() const { + return getImpl()->controlType(); + } + + std::string HeatPumpPlantLoopEIRHeating::flowMode() const { + return getImpl()->flowMode(); + } + + double HeatPumpPlantLoopEIRHeating::minimumPartLoadRatio() const { + return getImpl()->minimumPartLoadRatio(); + } + + double HeatPumpPlantLoopEIRHeating::minimumSourceInletTemperature() const { + return getImpl()->minimumSourceInletTemperature(); + } + + double HeatPumpPlantLoopEIRHeating::maximumSourceInletTemperature() const { + return getImpl()->maximumSourceInletTemperature(); + } + + boost::optional HeatPumpPlantLoopEIRHeating::minimumSupplyWaterTemperatureCurve() const { + return getImpl()->minimumSupplyWaterTemperatureCurve(); + } + + boost::optional HeatPumpPlantLoopEIRHeating::maximumSupplyWaterTemperatureCurve() const { + return getImpl()->maximumSupplyWaterTemperatureCurve(); + } + + boost::optional HeatPumpPlantLoopEIRHeating::dryOutdoorCorrectionFactorCurve() const { + return getImpl()->dryOutdoorCorrectionFactorCurve(); + } + + double HeatPumpPlantLoopEIRHeating::maximumOutdoorDryBulbTemperatureForDefrostOperation() const { + return getImpl()->maximumOutdoorDryBulbTemperatureForDefrostOperation(); + } + + std::string HeatPumpPlantLoopEIRHeating::heatPumpDefrostControl() const { + return getImpl()->heatPumpDefrostControl(); + } + + double HeatPumpPlantLoopEIRHeating::heatPumpDefrostTimePeriodFraction() const { + return getImpl()->heatPumpDefrostTimePeriodFraction(); + } + + boost::optional HeatPumpPlantLoopEIRHeating::defrostEnergyInputRatioFunctionofTemperatureCurve() const { + return getImpl()->defrostEnergyInputRatioFunctionofTemperatureCurve(); + } + + boost::optional HeatPumpPlantLoopEIRHeating::timedEmpiricalDefrostFrequencyCurve() const { + return getImpl()->timedEmpiricalDefrostFrequencyCurve(); + } + + boost::optional HeatPumpPlantLoopEIRHeating::timedEmpiricalDefrostHeatLoadPenaltyCurve() const { + return getImpl()->timedEmpiricalDefrostHeatLoadPenaltyCurve(); + } + + boost::optional HeatPumpPlantLoopEIRHeating::timedEmpiricalDefrostHeatInputEnergyFractionCurve() const { + return getImpl()->timedEmpiricalDefrostHeatInputEnergyFractionCurve(); + } + bool HeatPumpPlantLoopEIRHeating::setCondenserType(const std::string& condenserType) { return getImpl()->setCondenserType(condenserType); } @@ -574,6 +816,74 @@ namespace model { electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); } + bool HeatPumpPlantLoopEIRHeating::setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio) { + return getImpl()->setHeatingtoCoolingCapacitySizingRatio(heatingtoCoolingCapacitySizingRatio); + } + + bool HeatPumpPlantLoopEIRHeating::setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod) { + return getImpl()->setHeatPumpSizingMethod(heatPumpSizingMethod); + } + + bool HeatPumpPlantLoopEIRHeating::setControlType(const std::string& controlType) { + return getImpl()->setControlType(controlType); + } + + bool HeatPumpPlantLoopEIRHeating::setFlowMode(const std::string& flowMode) { + return getImpl()->setFlowMode(flowMode); + } + + bool HeatPumpPlantLoopEIRHeating::setMinimumPartLoadRatio(double minimumPartLoadRatio) { + return getImpl()->setMinimumPartLoadRatio(minimumPartLoadRatio); + } + + bool HeatPumpPlantLoopEIRHeating::setMinimumSourceInletTemperature(double minimumSourceInletTemperature) { + return getImpl()->setMinimumSourceInletTemperature(minimumSourceInletTemperature); + } + + bool HeatPumpPlantLoopEIRHeating::setMaximumSourceInletTemperature(double maximumSourceInletTemperature) { + return getImpl()->setMaximumSourceInletTemperature(maximumSourceInletTemperature); + } + + bool HeatPumpPlantLoopEIRHeating::setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve) { + return getImpl()->setMinimumSupplyWaterTemperatureCurve(minimumSupplyWaterTemperatureCurve); + } + + bool HeatPumpPlantLoopEIRHeating::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { + return getImpl()->setMaximumSupplyWaterTemperatureCurve(maximumSupplyWaterTemperatureCurve); + } + + bool HeatPumpPlantLoopEIRHeating::setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve) { + return getImpl()->setDryOutdoorCorrectionFactorCurve(dryOutdoorCorrectionFactorCurve); + } + + bool HeatPumpPlantLoopEIRHeating::setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation) { + return getImpl()->setMaximumOutdoorDryBulbTemperatureForDefrostOperation(maximumOutdoorDryBulbTemperatureForDefrostOperation); + } + + bool HeatPumpPlantLoopEIRHeating::setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl) { + return getImpl()->setHeatPumpDefrostControl(heatPumpDefrostControl); + } + + bool HeatPumpPlantLoopEIRHeating::setHeatPumpDefrostTimePeriodFraction(double heatPumpDefrostTimePeriodFraction) { + return getImpl()->setHeatPumpDefrostTimePeriodFraction(heatPumpDefrostTimePeriodFraction); + } + + bool HeatPumpPlantLoopEIRHeating::setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve) { + return getImpl()->setDefrostEnergyInputRatioFunctionofTemperatureCurve(defrostEnergyInputRatioFunctionofTemperatureCurve); + } + + bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve) { + return getImpl()->setTimedEmpiricalDefrostFrequencyCurve(timedEmpiricalDefrostFrequencyCurve); + } + + bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve) { + return getImpl()->setTimedEmpiricalDefrostHeatLoadPenaltyCurve(timedEmpiricalDefrostHeatLoadPenaltyCurve); + } + + bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve) { + return getImpl()->setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(timedEmpiricalDefrostHeatInputEnergyFractionCurve); + } + boost::optional HeatPumpPlantLoopEIRHeating::autosizedLoadSideReferenceFlowRate() const { return getImpl()->autosizedLoadSideReferenceFlowRate(); } diff --git a/src/model/HeatPumpPlantLoopEIRHeating.hpp b/src/model/HeatPumpPlantLoopEIRHeating.hpp index 3ebbac9eec0..e834caf9c05 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.hpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.hpp @@ -79,6 +79,40 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; + double heatingtoCoolingCapacitySizingRatio() const; + + std::string heatPumpSizingMethod() const; + + std::string controlType() const; + + std::string flowMode() const; + + double minimumPartLoadRatio() const; + + double minimumSourceInletTemperature() const; + + double maximumSourceInletTemperature() const; + + boost::optional minimumSupplyWaterTemperatureCurve() const; + + boost::optional maximumSupplyWaterTemperatureCurve() const; + + boost::optional dryOutdoorCorrectionFactorCurve() const; + + double maximumOutdoorDryBulbTemperatureForDefrostOperation() const; + + std::string heatPumpDefrostControl() const; + + double heatPumpDefrostTimePeriodFraction() const; + + boost::optional defrostEnergyInputRatioFunctionofTemperatureCurve() const; + + boost::optional timedEmpiricalDefrostFrequencyCurve() const; + + boost::optional timedEmpiricalDefrostHeatLoadPenaltyCurve() const; + + boost::optional timedEmpiricalDefrostHeatInputEnergyFractionCurve() const; + //@} /** @name Setters */ //@{ @@ -110,6 +144,40 @@ namespace model { bool setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(const Curve& electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); + bool setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio); + + bool setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod); + + bool setControlType(const std::string& controlType); + + bool setFlowMode(const std::string& flowMode); + + bool setMinimumPartLoadRatio(double minimumPartLoadRatio); + + bool setMinimumSourceInletTemperature(double minimumSourceInletTemperature); + + bool setMaximumSourceInletTemperature(double maximumSourceInletTemperature); + + bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); + + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); + + bool setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve); + + bool setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation); + + bool setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl); + + bool setHeatPumpDefrostTimePeriodFraction(double heatPumpDefrostTimePeriodFraction); + + bool setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve); + + bool setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve); + + bool setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve); + + bool setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve); + //@} /** @name Other */ //@{ diff --git a/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp b/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp index 4d3e84f12ee..e8c59aa097a 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp +++ b/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp @@ -96,6 +96,40 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; + double heatingtoCoolingCapacitySizingRatio() const; + + std::string heatPumpSizingMethod() const; + + std::string controlType() const; + + std::string flowMode() const; + + double minimumPartLoadRatio() const; + + double minimumSourceInletTemperature() const; + + double maximumSourceInletTemperature() const; + + boost::optional minimumSupplyWaterTemperatureCurve() const; + + boost::optional maximumSupplyWaterTemperatureCurve() const; + + boost::optional dryOutdoorCorrectionFactorCurve() const; + + double maximumOutdoorDryBulbTemperatureForDefrostOperation() const; + + std::string heatPumpDefrostControl() const; + + double heatPumpDefrostTimePeriodFraction() const; + + boost::optional defrostEnergyInputRatioFunctionofTemperatureCurve() const; + + boost::optional timedEmpiricalDefrostFrequencyCurve() const; + + boost::optional timedEmpiricalDefrostHeatLoadPenaltyCurve() const; + + boost::optional timedEmpiricalDefrostHeatInputEnergyFractionCurve() const; + //@} /** @name Setters */ //@{ @@ -127,6 +161,40 @@ namespace model { bool setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve( const Curve& electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); + bool setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio); + + bool setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod); + + bool setControlType(const std::string& controlType); + + bool setFlowMode(const std::string& flowMode); + + bool setMinimumPartLoadRatio(double minimumPartLoadRatio); + + bool setMinimumSourceInletTemperature(double minimumSourceInletTemperature); + + bool setMaximumSourceInletTemperature(double maximumSourceInletTemperature); + + bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); + + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); + + bool setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve); + + bool setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation); + + bool setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl); + + bool setHeatPumpDefrostTimePeriodFraction(double heatPumpDefrostTimePeriodFraction); + + bool setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve); + + bool setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve); + + bool setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve); + + bool setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve); + //@} /** @name Other */ //@{ From c52a4291f9cf81ebbeb5d25f6aefa0552f131bda Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 7 Sep 2023 09:53:35 -0700 Subject: [PATCH 08/18] Update model tests for heating. --- src/model/HeatPumpPlantLoopEIRHeating.cpp | 40 ++++++++--- .../HeatPumpPlantLoopEIRCooling_GTest.cpp | 6 +- .../HeatPumpPlantLoopEIRHeating_GTest.cpp | 66 +++++++++++++++++++ 3 files changed, 100 insertions(+), 12 deletions(-) diff --git a/src/model/HeatPumpPlantLoopEIRHeating.cpp b/src/model/HeatPumpPlantLoopEIRHeating.cpp index 25419bfe82b..54d6b0e9edd 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.cpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.cpp @@ -293,7 +293,7 @@ namespace model { } boost::optional HeatPumpPlantLoopEIRHeating_Impl::dryOutdoorCorrectionFactorCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurve); + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurveName); } double HeatPumpPlantLoopEIRHeating_Impl::maximumOutdoorDryBulbTemperatureForDefrostOperation() const { @@ -315,19 +315,19 @@ namespace model { } boost::optional HeatPumpPlantLoopEIRHeating_Impl::defrostEnergyInputRatioFunctionofTemperatureCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurve); + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName); } boost::optional HeatPumpPlantLoopEIRHeating_Impl::timedEmpiricalDefrostFrequencyCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurve); + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurveName); } boost::optional HeatPumpPlantLoopEIRHeating_Impl::timedEmpiricalDefrostHeatLoadPenaltyCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurve); + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName); } boost::optional HeatPumpPlantLoopEIRHeating_Impl::timedEmpiricalDefrostHeatInputEnergyFractionCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurve); + return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName); } bool HeatPumpPlantLoopEIRHeating_Impl::setCompanionCoolingHeatPump(const HeatPumpPlantLoopEIRCooling& companionHP) { @@ -434,7 +434,7 @@ namespace model { bool HeatPumpPlantLoopEIRHeating_Impl::setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve) { bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurve, dryOutdoorCorrectionFactorCurve.handle()); + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurveName, dryOutdoorCorrectionFactorCurve.handle()); return result; } @@ -453,25 +453,25 @@ namespace model { bool HeatPumpPlantLoopEIRHeating_Impl::setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve) { bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurve, defrostEnergyInputRatioFunctionofTemperatureCurve.handle()); + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName, defrostEnergyInputRatioFunctionofTemperatureCurve.handle()); return result; } bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve) { bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurve, timedEmpiricalDefrostFrequencyCurve.handle()); + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurveName, timedEmpiricalDefrostFrequencyCurve.handle()); return result; } bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve) { bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurve, timedEmpiricalDefrostHeatLoadPenaltyCurve.handle()); + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName, timedEmpiricalDefrostHeatLoadPenaltyCurve.handle()); return result; } bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve) { bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurve, timedEmpiricalDefrostHeatInputEnergyFractionCurve.handle()); + setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName, timedEmpiricalDefrostHeatInputEnergyFractionCurve.handle()); return result; } @@ -565,6 +565,16 @@ namespace model { setReferenceCoefficientofPerformance(7.5); // IDD default setSizingFactor(1.0); + setHeatingtoCoolingCapacitySizingRatio(1.0); + setHeatPumpSizingMethod("CoolingCapacity"); + setControlType("Load"); + setFlowMode("ConstantFlow"); + setMinimumPartLoadRatio(0.0); + setMinimumSourceInletTemperature(-100.0); + setMaximumSourceInletTemperature(100.0); + setMaximumOutdoorDryBulbTemperatureForDefrostOperation(10.0); + setHeatPumpDefrostControl("None"); + setHeatPumpDefrostTimePeriodFraction(0.058333); } HeatPumpPlantLoopEIRHeating::HeatPumpPlantLoopEIRHeating(const Model& model) @@ -625,6 +635,16 @@ namespace model { setReferenceCoefficientofPerformance(7.5); setSizingFactor(1.0); + setHeatingtoCoolingCapacitySizingRatio(1.0); + setHeatPumpSizingMethod("CoolingCapacity"); + setControlType("Load"); + setFlowMode("ConstantFlow"); + setMinimumPartLoadRatio(0.0); + setMinimumSourceInletTemperature(-100.0); + setMaximumSourceInletTemperature(100.0); + setMaximumOutdoorDryBulbTemperatureForDefrostOperation(10.0); + setHeatPumpDefrostControl("None"); + setHeatPumpDefrostTimePeriodFraction(0.058333); } IddObjectType HeatPumpPlantLoopEIRHeating::iddObjectType() { diff --git a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp index ecb2c959624..3669d457fd9 100644 --- a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp @@ -118,8 +118,10 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_GettersSetters) { EXPECT_EQ(1, hp.minimumPartLoadRatio()); EXPECT_EQ(2, hp.minimumSourceInletTemperature()); EXPECT_EQ(3, hp.maximumSourceInletTemeperature()); - EXPECT_EQ(curve4.handle(), hp.minimumSupplyWaterTemperatureCurve().handle()); - EXPECT_EQ(curve5.handle(), hp.maximumSupplyWaterTemperatureCurve().handle()); + ASSERT_TRUE(hp.minimumSupplyWaterTemperatureCurve()); + EXPECT_EQ(curve4.handle(), hp.minimumSupplyWaterTemperatureCurve().get().handle()); + ASSERT_TRUE(hp.maximumSupplyWaterTemperatureCurve()); + EXPECT_EQ(curve5.handle(), hp.maximumSupplyWaterTemperatureCurve().get().handle()); hp.autosizeLoadSideReferenceFlowRate(); EXPECT_TRUE(hp.isLoadSideReferenceFlowRateAutosized()); diff --git a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp index 268267120df..7b1ed425ca3 100644 --- a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp @@ -59,6 +59,23 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_HeatPumpPlantLoopEIRHeating) { boost::optional electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve = hp.electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(); EXPECT_TRUE(electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); + EXPECT_EQ(1.0, hp.heatingtoCoolingCapacitySizingRatio()); + EXPECT_EQ("CoolingCapacity", hp.heatPumpSizingMethod()); + EXPECT_EQ("Load", hp.controlType()); + EXPECT_EQ("ConstantFlow", hp.flowMode()); + EXPECT_EQ(0.0, hp.minimumPartLoadRatio()); + EXPECT_EQ(-100.0, hp.minimumSourceInletTemperature()); + EXPECT_EQ(100.0, hp.maximumSourceInletTemeperature()); + EXPECT_FALSE(hp.minimumSupplyWaterTemperatureCurve()); + EXPECT_FALSE(hp.maximumSupplyWaterTemperatureCurve()); + EXPECT_FALSE(hp.dryOutdoorCorrectionFactorCurve()); + EXPECT_EQ(10.0, hp.maximumOutdoorDryBulbTemperatureForDefrostOperation()); + EXPECT_EQ("None", hp.heatPumpDefrostControl()); + EXPECT_EQ(0.058333, hp.heatPumpDefrostTimePeriodFraction()); + EXPECT_FALSE(hp.defrostEnergyInputRatioFunctionofTemperatureCurve()); + EXPECT_FALSE(hp.timedEmpiricalDefrostFrequencyCurve()); + EXPECT_FALSE(hp.timedEmpiricalDefrostHeatLoadPenaltyCurve()); + EXPECT_FALSE(hp.timedEmpiricalDefrostHeatInputEnergyFractionCurve()); } TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_GettersSetters) { @@ -79,6 +96,30 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_GettersSetters) { EXPECT_TRUE(hp.setElectricInputtoOutputRatioModifierFunctionofTemperatureCurve(curve2)); CurveQuadratic curve3(m); EXPECT_TRUE(hp.setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(curve3)); + EXPECT_TRUE(hp.setHeatingtoCoolingCapacitySizingRatio(1)); + EXPECT_TRUE(hp.setHeatPumpSizingMethod("HeatingCapacity")); + EXPECT_TRUE(hp.setControlType("Setpoint")); + EXPECT_TRUE(hp.setFlowMode("VariableSpeedPumping")); + EXPECT_TRUE(hp.setMinimumPartLoadRatio(2)); + EXPECT_TRUE(hp.setMinimumSourceInletTemperature(3)); + EXPECT_TRUE(hp.setMaximumSourceInletTemperature(4)); + CurveQuadratic curve4(m); + EXPECT_TRUE(hp.setMinimumSupplyWaterTemperatureCurve(curve4)); + CurveQuadratic curve5(m); + EXPECT_TRUE(hp.setMaximumSupplyWaterTemperatureCurve(curve5)); + CurveQuadratic curve6(m); + EXPECT_TRUE(hp.setDryOutdoorCorrectionFactorCurve(curve6)); + EXPECT_TRUE(hp.setMaximumOutdoorDryBulbTemperatureForDefrostOperation(5)); + EXPECT_TRUE(hp.setHeatPumpDefrostControl("Timed")); + EXPECT_TRUE(hp.setHeatPumpDefrostTimePeriodFraction(6)); + CurveBiquadratic curve7(m); + EXPECT_TRUE(hp.setDefrostEnergyInputRatioFunctionofTemperatureCurve(curve7)); + CurveQuadratic curve8(m); + EXPECT_TRUE(hp.setTimedEmpiricalDefrostFrequencyCurve(curve8)); + CurveQuadratic curve9(m); + EXPECT_TRUE(hp.setTimedEmpiricalDefrostHeatLoadPenaltyCurve(curve9)); + CurveQuadratic curve10(m); + EXPECT_TRUE(hp.setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(curve10)); EXPECT_EQ("AirSource", hp.condenserType()); ASSERT_TRUE(hp.companionCoolingHeatPump()); @@ -98,6 +139,31 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_GettersSetters) { EXPECT_EQ(curve2.handle(), hp.electricInputtoOutputRatioModifierFunctionofTemperatureCurve().handle()); EXPECT_EQ(curve3.handle(), hp.electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve().handle()); + EXPECT_EQ(1, hp.heatingtoCoolingCapacitySizingRatio()); + EXPECT_EQ("HeatingCapacity", hp.heatPumpSizingMethod()); + EXPECT_EQ("Setpoint", hp.controlType()); + EXPECT_EQ("VariableSpeedPumping", hp.flowMode()); + EXPECT_EQ(2, hp.minimumPartLoadRatio()); + EXPECT_EQ(3, hp.minimumSourceInletTemperature()); + EXPECT_EQ(4, hp.maximumSourceInletTemeperature()); + ASSERT_TRUE(hp.minimumSupplyWaterTemperatureCurve()); + EXPECT_EQ(curve4.handle(), hp.minimumSupplyWaterTemperatureCurve().get().handle()); + ASSERT_TRUE(hp.maximumSupplyWaterTemperatureCurve()); + EXPECT_EQ(curve5.handle(), hp.maximumSupplyWaterTemperatureCurve().get().handle()); + ASSERT_TRUE(hp.dryOutdoorCorrectionFactorCurve()); + EXPECT_EQ(curve6.handle(), hp.dryOutdoorCorrectionFactorCurve().get().handle()); + EXPECT_EQ(5, hp.maximumOutdoorDryBulbTemperatureForDefrostOperation()); + EXPECT_EQ("Timed", hp.heatPumpDefrostControl()); + EXPECT_EQ(6, hp.heatPumpDefrostTimePeriodFraction()); + ASSERT_TRUE(hp.defrostEnergyInputRatioFunctionofTemperatureCurve()); + EXPECT_EQ(curve7.handle(), hp.defrostEnergyInputRatioFunctionofTemperatureCurve().get().handle()); + ASSERT_TRUE(hp.timedEmpiricalDefrostFrequencyCurve()); + EXPECT_EQ(curve8.handle(), hp.timedEmpiricalDefrostFrequencyCurve().get().handle()); + ASSERT_TRUE(hp.timedEmpiricalDefrostHeatLoadPenaltyCurve()); + EXPECT_EQ(curve9.handle(), hp.timedEmpiricalDefrostHeatLoadPenaltyCurve().get().handle()); + ASSERT_TRUE(hp.timedEmpiricalDefrostHeatInputEnergyFractionCurve()); + EXPECT_EQ(curve10.handle(), hp.timedEmpiricalDefrostHeatInputEnergyFractionCurve().get().handle()); + hp.autosizeLoadSideReferenceFlowRate(); EXPECT_TRUE(hp.isLoadSideReferenceFlowRateAutosized()); EXPECT_FALSE(hp.isSourceSideReferenceFlowRateAutosized()); From 2be916c001b2a303eb3eb65588d3fe1b150f360c Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 7 Sep 2023 10:06:37 -0700 Subject: [PATCH 09/18] Update ft and tests for heating. --- ...rdTranslateHeatPumpPlantLoopEIRHeating.cpp | 62 ++++++++++++++++++ .../Test/HeatPumpPlantLoopEIR_GTest.cpp | 64 ++++++++++++++++--- 2 files changed, 118 insertions(+), 8 deletions(-) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp index d5082d83beb..3a28cab249d 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp @@ -136,6 +136,68 @@ namespace energyplus { } } + idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatingtoCoolingCapacitySizingRatio, modelObject.heatingtoCoolingCapacitySizingRatio()); + + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpSizingMethod, modelObject.heatPumpSizingMethod()); + + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::ControlType, modelObject.controlType()); + + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::FlowMode, modelObject.flowMode()); + + idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::MinimumPartLoadRatio, modelObject.minimumPartLoadRatio()); + + idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::MinimumSourceInletTemperature, modelObject.minimumSourceInletTemperature()); + + idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumSourceInletTemperature, modelObject.maximumSourceInletTemperature()); + + if (boost::optional curve = modelObject.minimumSupplyWaterTemperatureCurve()) { + if (boost::optional _curve = translateAndMapModelObject(curve.get())) { + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::MinimumSupplyWaterTemperatureCurveName, _curve->name().get()); + } + } + + if (boost::optional curve = modelObject.maximumSupplyWaterTemperatureCurve()) { + if (boost::optional _curve = translateAndMapModelObject(curve.get())) { + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::MaximumSupplyWaterTemperatureCurveName, _curve->name().get()); + } + } + + if (boost::optional curve = modelObject.dryOutdoorCorrectionFactorCurve()) { + if (boost::optional _curve = translateAndMapModelObject(curve.get())) { + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurveName, _curve->name().get()); + } + } + + idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, modelObject.maximumOutdoorDryBulbTemperatureForDefrostOperation()); + + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostControl, modelObject.heatPumpDefrostControl()); + + idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostTimePeriodFraction, modelObject.heatPumpDefrostTimePeriodFraction()); + + if (boost::optional curve = modelObject.defrostEnergyInputRatioFunctionofTemperatureCurve()) { + if (boost::optional _curve = translateAndMapModelObject(curve.get())) { + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName, _curve->name().get()); + } + } + + if (boost::optional curve = modelObject.timedEmpiricalDefrostFrequencyCurve()) { + if (boost::optional _curve = translateAndMapModelObject(curve.get())) { + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurveName, _curve->name().get()); + } + } + + if (boost::optional curve = modelObject.timedEmpiricalDefrostHeatLoadPenaltyCurve()) { + if (boost::optional _curve = translateAndMapModelObject(curve.get())) { + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName, _curve->name().get()); + } + } + + if (boost::optional curve = modelObject.timedEmpiricalDefrostHeatInputEnergyFractionCurve()) { + if (boost::optional _curve = translateAndMapModelObject(curve.get())) { + idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName, _curve->name().get()); + } + } + return idfObject; } diff --git a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp index f63a0655361..631e098342e 100644 --- a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp +++ b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp @@ -65,12 +65,36 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { EXPECT_TRUE(plhp_htg.setReferenceCapacity(3.0)); EXPECT_TRUE(plhp_htg.setReferenceCoefficientofPerformance(4.0)); EXPECT_TRUE(plhp_htg.setSizingFactor(5.0)); - CurveBiquadratic curve4(m); - EXPECT_TRUE(plhp_htg.setCapacityModifierFunctionofTemperatureCurve(curve4)); - CurveBiquadratic curve5(m); - EXPECT_TRUE(plhp_htg.setElectricInputtoOutputRatioModifierFunctionofTemperatureCurve(curve5)); - CurveQuadratic curve6(m); - EXPECT_TRUE(plhp_htg.setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(curve6)); + CurveBiquadratic curve6(m); + EXPECT_TRUE(plhp_htg.setCapacityModifierFunctionofTemperatureCurve(curve6)); + CurveBiquadratic curve7(m); + EXPECT_TRUE(plhp_htg.setElectricInputtoOutputRatioModifierFunctionofTemperatureCurve(curve7)); + CurveQuadratic curve8(m); + EXPECT_TRUE(plhp_htg.setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(curve8)); + EXPECT_TRUE(plhp_htg.setHeatingtoCoolingCapacitySizingRatio(6.0)); + EXPECT_TRUE(plhp_htg.setHeatPumpSizingMethod("HeatingCapacity")); + EXPECT_TRUE(plhp_htg.setControlType("Setpoint")); + EXPECT_TRUE(plhp_htg.setFlowMode("VariableSpeedPumping")); + EXPECT_TRUE(plhp_htg.setMinimumPartLoadRatio(7.0)); + EXPECT_TRUE(plhp_htg.setMinimumSourceInletTemperature(8.0)); + EXPECT_TRUE(plhp_htg.setMaximumSourceInletTemperature(9.0)); + CurveQuadratic curve9(m); + EXPECT_TRUE(plhp_htg.setMinimumSupplyWaterTemperatureCurve(curve9)); + CurveQuadratic curve10(m); + EXPECT_TRUE(plhp_htg.setMaximumSupplyWaterTemperatureCurve(curve10)); + CurveQuadratic curve11(m); + EXPECT_TRUE(plhp_htg.setDryOutdoorCorrectionFactorCurve(curve11)); + EXPECT_TRUE(plhp_htg.setMaximumOutdoorDryBulbTemperatureForDefrostOperation(10.0)); + EXPECT_TRUE(plhp_htg.setHeatPumpDefrostControl("Timed")); + EXPECT_TRUE(plhp_htg.setHeatPumpDefrostTimePeriodFraction(11.0)); + CurveBiquadratic curve12(m); + EXPECT_TRUE(plhp_htg.setDefrostEnergyInputRatioFunctionofTemperatureCurve(curve12)); + CurveQuadratic curve13(m); + EXPECT_TRUE(plhp_htg.setTimedEmpiricalDefrostFrequencyCurve(curve13)); + CurveQuadratic curve14(m); + EXPECT_TRUE(plhp_htg.setTimedEmpiricalDefrostHeatLoadPenaltyCurve(curve14)); + CurveQuadratic curve15(m); + EXPECT_TRUE(plhp_htg.setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(curve15)); EXPECT_TRUE(plhp_clg.setCompanionHeatingHeatPump(plhp_htg)); EXPECT_TRUE(plhp_htg.setCompanionCoolingHeatPump(plhp_clg)); @@ -121,9 +145,9 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { EXPECT_EQ(6.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, false).get()); EXPECT_EQ(7.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, false).get()); EXPECT_EQ(8.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, false).get()); - boost::optional woCurve4(idf_cc.getTarget(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurve)); + boost::optional woCurve4(idf_cc.getTarget(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurveName)); EXPECT_TRUE(woCurve4); - boost::optional woCurve5(idf_cc.getTarget(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurve)); + boost::optional woCurve5(idf_cc.getTarget(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurveName)); EXPECT_TRUE(woCurve5); } @@ -156,6 +180,30 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::ElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurveName)); EXPECT_TRUE(woCurve3); EXPECT_EQ(woCurve3->iddObject().type(), IddObjectType::Curve_Quadratic); + EXPECT_EQ(6.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatingtoCoolingCapacitySizingRatio, false).get()); + EXPECT_EQ("HeatingCapacity", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpSizingMethod, false).get()); + EXPECT_EQ("Setpoint", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::ControlType, false).get()); + EXPECT_EQ("VariableSpeedPumping", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::FlowMode, false).get()); + EXPECT_EQ(7.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MinimumPartLoadRatio, false).get()); + EXPECT_EQ(8.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MinimumSourceInletTemperature, false).get()); + EXPECT_EQ(9.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumSourceInletTemeperature, false).get()); + boost::optional woCurve4(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::MinimumSupplyWaterTemperatureCurveName)); + EXPECT_TRUE(woCurve4); + boost::optional woCurve5(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::MaximumSupplyWaterTemperatureCurveName)); + EXPECT_TRUE(woCurve5); + boost::optional woCurve6(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::dryOutdoorCorrectionFactorCurveName)); + EXPECT_TRUE(woCurve6); + EXPECT_EQ(10.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, false).get()); + EXPECT_EQ("Timed", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostControl, false).get()); + EXPECT_EQ(11.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostTimePeriodFraction, false).get()); + boost::optional woCurve7(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName)); + EXPECT_TRUE(woCurve7); + boost::optional woCurve8(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurveName)); + EXPECT_TRUE(woCurve8); + boost::optional woCurve9(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName)); + EXPECT_TRUE(woCurve9); + boost::optional woCurve10(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName)); + EXPECT_TRUE(woCurve10); } } From 6b6204fb2e9b3276df4ef01456d27f949e3742ed Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 7 Sep 2023 10:06:53 -0700 Subject: [PATCH 10/18] Formatting. --- ...rdTranslateHeatPumpPlantLoopEIRHeating.cpp | 5 +- .../Test/HeatPumpPlantLoopEIR_GTest.cpp | 6 +- src/model/HeatPumpPlantLoopEIRHeating.cpp | 132 ++++++++++-------- src/model/HeatPumpPlantLoopEIRHeating.hpp | 38 ++--- .../HeatPumpPlantLoopEIRHeating_Impl.hpp | 38 ++--- .../HeatPumpPlantLoopEIRHeating_GTest.cpp | 2 +- 6 files changed, 119 insertions(+), 102 deletions(-) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp index 3a28cab249d..8a64a31b4da 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp @@ -168,12 +168,13 @@ namespace energyplus { } } - idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, modelObject.maximumOutdoorDryBulbTemperatureForDefrostOperation()); + idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, + modelObject.maximumOutdoorDryBulbTemperatureForDefrostOperation()); idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostControl, modelObject.heatPumpDefrostControl()); idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostTimePeriodFraction, modelObject.heatPumpDefrostTimePeriodFraction()); - + if (boost::optional curve = modelObject.defrostEnergyInputRatioFunctionofTemperatureCurve()) { if (boost::optional _curve = translateAndMapModelObject(curve.get())) { idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName, _curve->name().get()); diff --git a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp index 631e098342e..7684387bcaa 100644 --- a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp +++ b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp @@ -196,13 +196,15 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { EXPECT_EQ(10.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, false).get()); EXPECT_EQ("Timed", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostControl, false).get()); EXPECT_EQ(11.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostTimePeriodFraction, false).get()); - boost::optional woCurve7(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName)); + boost::optional woCurve7( + idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName)); EXPECT_TRUE(woCurve7); boost::optional woCurve8(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurveName)); EXPECT_TRUE(woCurve8); boost::optional woCurve9(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName)); EXPECT_TRUE(woCurve9); - boost::optional woCurve10(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName)); + boost::optional woCurve10( + idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName)); EXPECT_TRUE(woCurve10); } } diff --git a/src/model/HeatPumpPlantLoopEIRHeating.cpp b/src/model/HeatPumpPlantLoopEIRHeating.cpp index 54d6b0e9edd..0f899cd3a36 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.cpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.cpp @@ -247,13 +247,13 @@ namespace model { OS_ASSERT(value); return value.get(); } - + std::string HeatPumpPlantLoopEIRHeating_Impl::heatPumpSizingMethod() const { boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpSizingMethod, true); OS_ASSERT(value); return value.get(); } - + std::string HeatPumpPlantLoopEIRHeating_Impl::controlType() const { boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_HeatingFields::ControlType, true); OS_ASSERT(value); @@ -291,43 +291,46 @@ namespace model { boost::optional HeatPumpPlantLoopEIRHeating_Impl::maximumSupplyWaterTemperatureCurve() const { return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumSupplyWaterTemperatureCurveName); } - + boost::optional HeatPumpPlantLoopEIRHeating_Impl::dryOutdoorCorrectionFactorCurve() const { return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurveName); } - + double HeatPumpPlantLoopEIRHeating_Impl::maximumOutdoorDryBulbTemperatureForDefrostOperation() const { boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, true); OS_ASSERT(value); return value.get(); } - + std::string HeatPumpPlantLoopEIRHeating_Impl::heatPumpDefrostControl() const { boost::optional value = getString(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostControl, true); OS_ASSERT(value); return value.get(); } - + double HeatPumpPlantLoopEIRHeating_Impl::heatPumpDefrostTimePeriodFraction() const { boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostTimePeriodFraction, true); OS_ASSERT(value); return value.get(); } - + boost::optional HeatPumpPlantLoopEIRHeating_Impl::defrostEnergyInputRatioFunctionofTemperatureCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName); + return getObject().getModelObjectTarget( + OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName); } - + boost::optional HeatPumpPlantLoopEIRHeating_Impl::timedEmpiricalDefrostFrequencyCurve() const { return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurveName); } - + boost::optional HeatPumpPlantLoopEIRHeating_Impl::timedEmpiricalDefrostHeatLoadPenaltyCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName); + return getObject().getModelObjectTarget( + OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName); } - + boost::optional HeatPumpPlantLoopEIRHeating_Impl::timedEmpiricalDefrostHeatInputEnergyFractionCurve() const { - return getObject().getModelObjectTarget(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName); + return getObject().getModelObjectTarget( + OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName); } bool HeatPumpPlantLoopEIRHeating_Impl::setCompanionCoolingHeatPump(const HeatPumpPlantLoopEIRCooling& companionHP) { @@ -395,9 +398,9 @@ namespace model { bool HeatPumpPlantLoopEIRHeating_Impl::setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod) { bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpSizingMethod, heatPumpSizingMethod); - return result; + return result; } - + bool HeatPumpPlantLoopEIRHeating_Impl::setControlType(const std::string& controlType) { bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::ControlType, controlType); return result; @@ -431,47 +434,51 @@ namespace model { setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumSupplyWaterTemperatureCurveName, maximumSupplyWaterTemperatureCurve.handle()); return result; } - + bool HeatPumpPlantLoopEIRHeating_Impl::setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve) { bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurveName, dryOutdoorCorrectionFactorCurve.handle()); return result; } - - bool HeatPumpPlantLoopEIRHeating_Impl::setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation) { - return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, maximumOutdoorDryBulbTemperatureForDefrostOperation); + + bool HeatPumpPlantLoopEIRHeating_Impl::setMaximumOutdoorDryBulbTemperatureForDefrostOperation( + double maximumOutdoorDryBulbTemperatureForDefrostOperation) { + return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, + maximumOutdoorDryBulbTemperatureForDefrostOperation); } - + bool HeatPumpPlantLoopEIRHeating_Impl::setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl) { bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostControl, heatPumpDefrostControl); - return result; + return result; } - + bool HeatPumpPlantLoopEIRHeating_Impl::setHeatPumpDefrostTimePeriodFraction(double heatPumpDefrostTimePeriodFraction) { return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostTimePeriodFraction, heatPumpDefrostTimePeriodFraction); } - - bool HeatPumpPlantLoopEIRHeating_Impl::setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve) { - bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName, defrostEnergyInputRatioFunctionofTemperatureCurve.handle()); + + bool HeatPumpPlantLoopEIRHeating_Impl::setDefrostEnergyInputRatioFunctionofTemperatureCurve( + const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve) { + bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName, + defrostEnergyInputRatioFunctionofTemperatureCurve.handle()); return result; } - + bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve) { bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurveName, timedEmpiricalDefrostFrequencyCurve.handle()); return result; } - + bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve) { - bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName, timedEmpiricalDefrostHeatLoadPenaltyCurve.handle()); + bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName, + timedEmpiricalDefrostHeatLoadPenaltyCurve.handle()); return result; } - - bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve) { - bool result = - setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName, timedEmpiricalDefrostHeatInputEnergyFractionCurve.handle()); + + bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve( + const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve) { + bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName, + timedEmpiricalDefrostHeatInputEnergyFractionCurve.handle()); return result; } @@ -714,11 +721,11 @@ namespace model { double HeatPumpPlantLoopEIRHeating::heatingtoCoolingCapacitySizingRatio() const { return getImpl()->heatingtoCoolingCapacitySizingRatio(); } - + std::string HeatPumpPlantLoopEIRHeating::heatPumpSizingMethod() const { return getImpl()->heatPumpSizingMethod(); } - + std::string HeatPumpPlantLoopEIRHeating::controlType() const { return getImpl()->controlType(); } @@ -746,19 +753,19 @@ namespace model { boost::optional HeatPumpPlantLoopEIRHeating::maximumSupplyWaterTemperatureCurve() const { return getImpl()->maximumSupplyWaterTemperatureCurve(); } - + boost::optional HeatPumpPlantLoopEIRHeating::dryOutdoorCorrectionFactorCurve() const { return getImpl()->dryOutdoorCorrectionFactorCurve(); } - + double HeatPumpPlantLoopEIRHeating::maximumOutdoorDryBulbTemperatureForDefrostOperation() const { return getImpl()->maximumOutdoorDryBulbTemperatureForDefrostOperation(); } - + std::string HeatPumpPlantLoopEIRHeating::heatPumpDefrostControl() const { return getImpl()->heatPumpDefrostControl(); } - + double HeatPumpPlantLoopEIRHeating::heatPumpDefrostTimePeriodFraction() const { return getImpl()->heatPumpDefrostTimePeriodFraction(); } @@ -766,15 +773,15 @@ namespace model { boost::optional HeatPumpPlantLoopEIRHeating::defrostEnergyInputRatioFunctionofTemperatureCurve() const { return getImpl()->defrostEnergyInputRatioFunctionofTemperatureCurve(); } - + boost::optional HeatPumpPlantLoopEIRHeating::timedEmpiricalDefrostFrequencyCurve() const { return getImpl()->timedEmpiricalDefrostFrequencyCurve(); } - + boost::optional HeatPumpPlantLoopEIRHeating::timedEmpiricalDefrostHeatLoadPenaltyCurve() const { return getImpl()->timedEmpiricalDefrostHeatLoadPenaltyCurve(); } - + boost::optional HeatPumpPlantLoopEIRHeating::timedEmpiricalDefrostHeatInputEnergyFractionCurve() const { return getImpl()->timedEmpiricalDefrostHeatInputEnergyFractionCurve(); } @@ -843,7 +850,7 @@ namespace model { bool HeatPumpPlantLoopEIRHeating::setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod) { return getImpl()->setHeatPumpSizingMethod(heatPumpSizingMethod); } - + bool HeatPumpPlantLoopEIRHeating::setControlType(const std::string& controlType) { return getImpl()->setControlType(controlType); } @@ -871,37 +878,44 @@ namespace model { bool HeatPumpPlantLoopEIRHeating::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { return getImpl()->setMaximumSupplyWaterTemperatureCurve(maximumSupplyWaterTemperatureCurve); } - + bool HeatPumpPlantLoopEIRHeating::setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve) { return getImpl()->setDryOutdoorCorrectionFactorCurve(dryOutdoorCorrectionFactorCurve); } - - bool HeatPumpPlantLoopEIRHeating::setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation) { - return getImpl()->setMaximumOutdoorDryBulbTemperatureForDefrostOperation(maximumOutdoorDryBulbTemperatureForDefrostOperation); + + bool + HeatPumpPlantLoopEIRHeating::setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation) { + return getImpl()->setMaximumOutdoorDryBulbTemperatureForDefrostOperation( + maximumOutdoorDryBulbTemperatureForDefrostOperation); } - + bool HeatPumpPlantLoopEIRHeating::setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl) { return getImpl()->setHeatPumpDefrostControl(heatPumpDefrostControl); } - + bool HeatPumpPlantLoopEIRHeating::setHeatPumpDefrostTimePeriodFraction(double heatPumpDefrostTimePeriodFraction) { return getImpl()->setHeatPumpDefrostTimePeriodFraction(heatPumpDefrostTimePeriodFraction); } - - bool HeatPumpPlantLoopEIRHeating::setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve) { - return getImpl()->setDefrostEnergyInputRatioFunctionofTemperatureCurve(defrostEnergyInputRatioFunctionofTemperatureCurve); + + bool HeatPumpPlantLoopEIRHeating::setDefrostEnergyInputRatioFunctionofTemperatureCurve( + const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve) { + return getImpl()->setDefrostEnergyInputRatioFunctionofTemperatureCurve( + defrostEnergyInputRatioFunctionofTemperatureCurve); } - + bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve) { return getImpl()->setTimedEmpiricalDefrostFrequencyCurve(timedEmpiricalDefrostFrequencyCurve); } - + bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve) { - return getImpl()->setTimedEmpiricalDefrostHeatLoadPenaltyCurve(timedEmpiricalDefrostHeatLoadPenaltyCurve); + return getImpl()->setTimedEmpiricalDefrostHeatLoadPenaltyCurve( + timedEmpiricalDefrostHeatLoadPenaltyCurve); } - - bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve) { - return getImpl()->setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(timedEmpiricalDefrostHeatInputEnergyFractionCurve); + + bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve( + const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve) { + return getImpl()->setTimedEmpiricalDefrostHeatInputEnergyFractionCurve( + timedEmpiricalDefrostHeatInputEnergyFractionCurve); } boost::optional HeatPumpPlantLoopEIRHeating::autosizedLoadSideReferenceFlowRate() const { diff --git a/src/model/HeatPumpPlantLoopEIRHeating.hpp b/src/model/HeatPumpPlantLoopEIRHeating.hpp index e834caf9c05..7b3c9944323 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.hpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.hpp @@ -80,9 +80,9 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; double heatingtoCoolingCapacitySizingRatio() const; - + std::string heatPumpSizingMethod() const; - + std::string controlType() const; std::string flowMode() const; @@ -96,21 +96,21 @@ namespace model { boost::optional minimumSupplyWaterTemperatureCurve() const; boost::optional maximumSupplyWaterTemperatureCurve() const; - + boost::optional dryOutdoorCorrectionFactorCurve() const; - + double maximumOutdoorDryBulbTemperatureForDefrostOperation() const; - + std::string heatPumpDefrostControl() const; - + double heatPumpDefrostTimePeriodFraction() const; - + boost::optional defrostEnergyInputRatioFunctionofTemperatureCurve() const; - + boost::optional timedEmpiricalDefrostFrequencyCurve() const; - + boost::optional timedEmpiricalDefrostHeatLoadPenaltyCurve() const; - + boost::optional timedEmpiricalDefrostHeatInputEnergyFractionCurve() const; //@} @@ -147,7 +147,7 @@ namespace model { bool setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio); bool setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod); - + bool setControlType(const std::string& controlType); bool setFlowMode(const std::string& flowMode); @@ -161,21 +161,21 @@ namespace model { bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); - + bool setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve); - + bool setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation); - + bool setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl); - + bool setHeatPumpDefrostTimePeriodFraction(double heatPumpDefrostTimePeriodFraction); - + bool setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve); - + bool setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve); - + bool setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve); - + bool setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve); //@} diff --git a/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp b/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp index e8c59aa097a..631edf587f6 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp +++ b/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp @@ -97,9 +97,9 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; double heatingtoCoolingCapacitySizingRatio() const; - + std::string heatPumpSizingMethod() const; - + std::string controlType() const; std::string flowMode() const; @@ -113,21 +113,21 @@ namespace model { boost::optional minimumSupplyWaterTemperatureCurve() const; boost::optional maximumSupplyWaterTemperatureCurve() const; - + boost::optional dryOutdoorCorrectionFactorCurve() const; - + double maximumOutdoorDryBulbTemperatureForDefrostOperation() const; - + std::string heatPumpDefrostControl() const; - + double heatPumpDefrostTimePeriodFraction() const; - + boost::optional defrostEnergyInputRatioFunctionofTemperatureCurve() const; - + boost::optional timedEmpiricalDefrostFrequencyCurve() const; - + boost::optional timedEmpiricalDefrostHeatLoadPenaltyCurve() const; - + boost::optional timedEmpiricalDefrostHeatInputEnergyFractionCurve() const; //@} @@ -164,7 +164,7 @@ namespace model { bool setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio); bool setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod); - + bool setControlType(const std::string& controlType); bool setFlowMode(const std::string& flowMode); @@ -178,21 +178,21 @@ namespace model { bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); - + bool setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve); - + bool setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation); - + bool setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl); - + bool setHeatPumpDefrostTimePeriodFraction(double heatPumpDefrostTimePeriodFraction); - + bool setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve); - + bool setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve); - + bool setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve); - + bool setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve); //@} diff --git a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp index 7b1ed425ca3..1a1bdacd9f7 100644 --- a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp @@ -119,7 +119,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_GettersSetters) { CurveQuadratic curve9(m); EXPECT_TRUE(hp.setTimedEmpiricalDefrostHeatLoadPenaltyCurve(curve9)); CurveQuadratic curve10(m); - EXPECT_TRUE(hp.setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(curve10)); + EXPECT_TRUE(hp.setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(curve10)); EXPECT_EQ("AirSource", hp.condenserType()); ASSERT_TRUE(hp.companionCoolingHeatPump()); From 13a2946cf731748d2bb4c15e08328981b93260b5 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 7 Sep 2023 11:11:40 -0700 Subject: [PATCH 11/18] Fix case in a heating field. --- ...rdTranslateHeatPumpPlantLoopEIRHeating.cpp | 2 +- .../Test/HeatPumpPlantLoopEIR_GTest.cpp | 4 ++-- src/model/HeatPumpPlantLoopEIRHeating.cpp | 20 +++++++++---------- src/model/HeatPumpPlantLoopEIRHeating.hpp | 4 ++-- .../HeatPumpPlantLoopEIRHeating_Impl.hpp | 4 ++-- .../HeatPumpPlantLoopEIRHeating_GTest.cpp | 6 +++--- 6 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp index 8a64a31b4da..be05d50f746 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRHeating.cpp @@ -136,7 +136,7 @@ namespace energyplus { } } - idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatingtoCoolingCapacitySizingRatio, modelObject.heatingtoCoolingCapacitySizingRatio()); + idfObject.setDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatingToCoolingCapacitySizingRatio, modelObject.heatingToCoolingCapacitySizingRatio()); idfObject.setString(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpSizingMethod, modelObject.heatPumpSizingMethod()); diff --git a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp index 7684387bcaa..4dfc5000ff1 100644 --- a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp +++ b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp @@ -71,7 +71,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { EXPECT_TRUE(plhp_htg.setElectricInputtoOutputRatioModifierFunctionofTemperatureCurve(curve7)); CurveQuadratic curve8(m); EXPECT_TRUE(plhp_htg.setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(curve8)); - EXPECT_TRUE(plhp_htg.setHeatingtoCoolingCapacitySizingRatio(6.0)); + EXPECT_TRUE(plhp_htg.setHeatingToCoolingCapacitySizingRatio(6.0)); EXPECT_TRUE(plhp_htg.setHeatPumpSizingMethod("HeatingCapacity")); EXPECT_TRUE(plhp_htg.setControlType("Setpoint")); EXPECT_TRUE(plhp_htg.setFlowMode("VariableSpeedPumping")); @@ -180,7 +180,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::ElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurveName)); EXPECT_TRUE(woCurve3); EXPECT_EQ(woCurve3->iddObject().type(), IddObjectType::Curve_Quadratic); - EXPECT_EQ(6.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatingtoCoolingCapacitySizingRatio, false).get()); + EXPECT_EQ(6.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::HeatingToCoolingCapacitySizingRatio, false).get()); EXPECT_EQ("HeatingCapacity", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpSizingMethod, false).get()); EXPECT_EQ("Setpoint", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::ControlType, false).get()); EXPECT_EQ("VariableSpeedPumping", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::FlowMode, false).get()); diff --git a/src/model/HeatPumpPlantLoopEIRHeating.cpp b/src/model/HeatPumpPlantLoopEIRHeating.cpp index 0f899cd3a36..80669285f3f 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.cpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.cpp @@ -242,8 +242,8 @@ namespace model { return wo.optionalCast().get(); } - double HeatPumpPlantLoopEIRHeating_Impl::heatingtoCoolingCapacitySizingRatio() const { - boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatingtoCoolingCapacitySizingRatio, true); + double HeatPumpPlantLoopEIRHeating_Impl::heatingToCoolingCapacitySizingRatio() const { + boost::optional value = getDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatingToCoolingCapacitySizingRatio, true); OS_ASSERT(value); return value.get(); } @@ -392,8 +392,8 @@ namespace model { return result; } - bool HeatPumpPlantLoopEIRHeating_Impl::setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio) { - return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatingtoCoolingCapacitySizingRatio, heatingtoCoolingCapacitySizingRatio); + bool HeatPumpPlantLoopEIRHeating_Impl::setHeatingToCoolingCapacitySizingRatio(double heatingToCoolingCapacitySizingRatio) { + return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::HeatingToCoolingCapacitySizingRatio, heatingToCoolingCapacitySizingRatio); } bool HeatPumpPlantLoopEIRHeating_Impl::setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod) { @@ -572,7 +572,7 @@ namespace model { setReferenceCoefficientofPerformance(7.5); // IDD default setSizingFactor(1.0); - setHeatingtoCoolingCapacitySizingRatio(1.0); + setHeatingToCoolingCapacitySizingRatio(1.0); setHeatPumpSizingMethod("CoolingCapacity"); setControlType("Load"); setFlowMode("ConstantFlow"); @@ -642,7 +642,7 @@ namespace model { setReferenceCoefficientofPerformance(7.5); setSizingFactor(1.0); - setHeatingtoCoolingCapacitySizingRatio(1.0); + setHeatingToCoolingCapacitySizingRatio(1.0); setHeatPumpSizingMethod("CoolingCapacity"); setControlType("Load"); setFlowMode("ConstantFlow"); @@ -718,8 +718,8 @@ namespace model { return getImpl()->electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(); } - double HeatPumpPlantLoopEIRHeating::heatingtoCoolingCapacitySizingRatio() const { - return getImpl()->heatingtoCoolingCapacitySizingRatio(); + double HeatPumpPlantLoopEIRHeating::heatingToCoolingCapacitySizingRatio() const { + return getImpl()->heatingToCoolingCapacitySizingRatio(); } std::string HeatPumpPlantLoopEIRHeating::heatPumpSizingMethod() const { @@ -843,8 +843,8 @@ namespace model { electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); } - bool HeatPumpPlantLoopEIRHeating::setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio) { - return getImpl()->setHeatingtoCoolingCapacitySizingRatio(heatingtoCoolingCapacitySizingRatio); + bool HeatPumpPlantLoopEIRHeating::setHeatingToCoolingCapacitySizingRatio(double heatingToCoolingCapacitySizingRatio) { + return getImpl()->setHeatingToCoolingCapacitySizingRatio(heatingToCoolingCapacitySizingRatio); } bool HeatPumpPlantLoopEIRHeating::setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod) { diff --git a/src/model/HeatPumpPlantLoopEIRHeating.hpp b/src/model/HeatPumpPlantLoopEIRHeating.hpp index 7b3c9944323..81ab04601fc 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.hpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.hpp @@ -79,7 +79,7 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; - double heatingtoCoolingCapacitySizingRatio() const; + double heatingToCoolingCapacitySizingRatio() const; std::string heatPumpSizingMethod() const; @@ -144,7 +144,7 @@ namespace model { bool setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(const Curve& electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); - bool setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio); + bool setHeatingToCoolingCapacitySizingRatio(double heatingToCoolingCapacitySizingRatio); bool setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod); diff --git a/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp b/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp index 631edf587f6..2de107b7ed6 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp +++ b/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp @@ -96,7 +96,7 @@ namespace model { Curve electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve() const; - double heatingtoCoolingCapacitySizingRatio() const; + double heatingToCoolingCapacitySizingRatio() const; std::string heatPumpSizingMethod() const; @@ -161,7 +161,7 @@ namespace model { bool setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve( const Curve& electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); - bool setHeatingtoCoolingCapacitySizingRatio(double heatingtoCoolingCapacitySizingRatio); + bool setHeatingToCoolingCapacitySizingRatio(double heatingToCoolingCapacitySizingRatio); bool setHeatPumpSizingMethod(const std::string& heatPumpSizingMethod); diff --git a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp index 1a1bdacd9f7..6923af0977d 100644 --- a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp @@ -59,7 +59,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_HeatPumpPlantLoopEIRHeating) { boost::optional electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve = hp.electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(); EXPECT_TRUE(electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve); - EXPECT_EQ(1.0, hp.heatingtoCoolingCapacitySizingRatio()); + EXPECT_EQ(1.0, hp.heatingToCoolingCapacitySizingRatio()); EXPECT_EQ("CoolingCapacity", hp.heatPumpSizingMethod()); EXPECT_EQ("Load", hp.controlType()); EXPECT_EQ("ConstantFlow", hp.flowMode()); @@ -96,7 +96,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_GettersSetters) { EXPECT_TRUE(hp.setElectricInputtoOutputRatioModifierFunctionofTemperatureCurve(curve2)); CurveQuadratic curve3(m); EXPECT_TRUE(hp.setElectricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve(curve3)); - EXPECT_TRUE(hp.setHeatingtoCoolingCapacitySizingRatio(1)); + EXPECT_TRUE(hp.setHeatingToCoolingCapacitySizingRatio(1)); EXPECT_TRUE(hp.setHeatPumpSizingMethod("HeatingCapacity")); EXPECT_TRUE(hp.setControlType("Setpoint")); EXPECT_TRUE(hp.setFlowMode("VariableSpeedPumping")); @@ -139,7 +139,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_GettersSetters) { EXPECT_EQ(curve2.handle(), hp.electricInputtoOutputRatioModifierFunctionofTemperatureCurve().handle()); EXPECT_EQ(curve3.handle(), hp.electricInputtoOutputRatioModifierFunctionofPartLoadRatioCurve().handle()); - EXPECT_EQ(1, hp.heatingtoCoolingCapacitySizingRatio()); + EXPECT_EQ(1, hp.heatingToCoolingCapacitySizingRatio()); EXPECT_EQ("HeatingCapacity", hp.heatPumpSizingMethod()); EXPECT_EQ("Setpoint", hp.controlType()); EXPECT_EQ("VariableSpeedPumping", hp.flowMode()); From 41504b716209154a18c0d4aac1b064411659b18e Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 7 Sep 2023 12:09:20 -0700 Subject: [PATCH 12/18] Typos in model test files. --- src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp | 4 ++-- src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp index 3669d457fd9..de229d91617 100644 --- a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp @@ -63,7 +63,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_HeatPumpPlantLoopEIRCooling) { EXPECT_EQ("ConstantFlow", hp.flowMode()); EXPECT_EQ(0.0, hp.minimumPartLoadRatio()); EXPECT_EQ(-100.0, hp.minimumSourceInletTemperature()); - EXPECT_EQ(100.0, hp.maximumSourceInletTemeperature()); + EXPECT_EQ(100.0, hp.maximumSourceInletTemperature()); EXPECT_FALSE(hp.minimumSupplyWaterTemperatureCurve()); EXPECT_FALSE(hp.maximumSupplyWaterTemperatureCurve()); } @@ -117,7 +117,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_GettersSetters) { EXPECT_EQ("VariableSpeedPumping", hp.flowMode()); EXPECT_EQ(1, hp.minimumPartLoadRatio()); EXPECT_EQ(2, hp.minimumSourceInletTemperature()); - EXPECT_EQ(3, hp.maximumSourceInletTemeperature()); + EXPECT_EQ(3, hp.maximumSourceInletTemperature()); ASSERT_TRUE(hp.minimumSupplyWaterTemperatureCurve()); EXPECT_EQ(curve4.handle(), hp.minimumSupplyWaterTemperatureCurve().get().handle()); ASSERT_TRUE(hp.maximumSupplyWaterTemperatureCurve()); diff --git a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp index 6923af0977d..299ddb6a5ac 100644 --- a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp @@ -65,7 +65,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_HeatPumpPlantLoopEIRHeating) { EXPECT_EQ("ConstantFlow", hp.flowMode()); EXPECT_EQ(0.0, hp.minimumPartLoadRatio()); EXPECT_EQ(-100.0, hp.minimumSourceInletTemperature()); - EXPECT_EQ(100.0, hp.maximumSourceInletTemeperature()); + EXPECT_EQ(100.0, hp.maximumSourceInletTemperature()); EXPECT_FALSE(hp.minimumSupplyWaterTemperatureCurve()); EXPECT_FALSE(hp.maximumSupplyWaterTemperatureCurve()); EXPECT_FALSE(hp.dryOutdoorCorrectionFactorCurve()); @@ -145,7 +145,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_GettersSetters) { EXPECT_EQ("VariableSpeedPumping", hp.flowMode()); EXPECT_EQ(2, hp.minimumPartLoadRatio()); EXPECT_EQ(3, hp.minimumSourceInletTemperature()); - EXPECT_EQ(4, hp.maximumSourceInletTemeperature()); + EXPECT_EQ(4, hp.maximumSourceInletTemperature()); ASSERT_TRUE(hp.minimumSupplyWaterTemperatureCurve()); EXPECT_EQ(curve4.handle(), hp.minimumSupplyWaterTemperatureCurve().get().handle()); ASSERT_TRUE(hp.maximumSupplyWaterTemperatureCurve()); From 4b09e64aaea6fcfed6721b2aaeda2b41722fe2fc Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 7 Sep 2023 12:47:20 -0700 Subject: [PATCH 13/18] More typos in ft test file. --- src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp index 4dfc5000ff1..ce3f1501398 100644 --- a/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp +++ b/src/energyplus/Test/HeatPumpPlantLoopEIR_GTest.cpp @@ -144,7 +144,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { EXPECT_EQ("VariableSpeedPumping", idf_cc.getString(HeatPump_PlantLoop_EIR_CoolingFields::FlowMode, false).get()); EXPECT_EQ(6.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MinimumPartLoadRatio, false).get()); EXPECT_EQ(7.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSourceInletTemperature, false).get()); - EXPECT_EQ(8.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemeperature, false).get()); + EXPECT_EQ(8.0, idf_cc.getDouble(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSourceInletTemperature, false).get()); boost::optional woCurve4(idf_cc.getTarget(HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurveName)); EXPECT_TRUE(woCurve4); boost::optional woCurve5(idf_cc.getTarget(HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurveName)); @@ -186,12 +186,12 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_HeatPumpPlantLoopEIR_AirSource) { EXPECT_EQ("VariableSpeedPumping", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::FlowMode, false).get()); EXPECT_EQ(7.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MinimumPartLoadRatio, false).get()); EXPECT_EQ(8.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MinimumSourceInletTemperature, false).get()); - EXPECT_EQ(9.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumSourceInletTemeperature, false).get()); + EXPECT_EQ(9.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumSourceInletTemperature, false).get()); boost::optional woCurve4(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::MinimumSupplyWaterTemperatureCurveName)); EXPECT_TRUE(woCurve4); boost::optional woCurve5(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::MaximumSupplyWaterTemperatureCurveName)); EXPECT_TRUE(woCurve5); - boost::optional woCurve6(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::dryOutdoorCorrectionFactorCurveName)); + boost::optional woCurve6(idf_hc.getTarget(HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurveName)); EXPECT_TRUE(woCurve6); EXPECT_EQ(10.0, idf_hc.getDouble(HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, false).get()); EXPECT_EQ("Timed", idf_hc.getString(HeatPump_PlantLoop_EIR_HeatingFields::HeatPumpDefrostControl, false).get()); From 6f8a3793e9c0a49b39f57000d0c53698ef61e562 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Thu, 7 Sep 2023 14:14:18 -0700 Subject: [PATCH 14/18] Typo in heating idd. --- resources/model/OpenStudio.idd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index bf58af890f9..f2504329727 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -14055,7 +14055,7 @@ OS:HeatPump:PlantLoop:EIR:Heating, \note curve = a + b*CWS + c*CWS**2 + d*ECT + e*ECT**2 + f*CWS*ECT \note CWS = supply (leaving) hot water temperature(C) \note ECT = entering condenser fluid temperature(C) - A11;\field Electric Input to Output Ratio Modifier Function of Part Load Ratio Curve Name + A11,\field Electric Input to Output Ratio Modifier Function of Part Load Ratio Curve Name \note Electric Input Ratio (EIR) modifier as a function of Part Load Ratio (PLR) \note EIR = 1/COP \required-field From c8d90297c8b4da38f4d60430c17749411f569095 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Tue, 12 Sep 2023 08:07:00 -0700 Subject: [PATCH 15/18] Update min fields in idd. --- resources/model/OpenStudio.idd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index f2504329727..6bbdcf1c936 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -13969,7 +13969,7 @@ OS:HeatPump:WaterToWater:EquationFit:Cooling, OS:HeatPump:PlantLoop:EIR:Heating, \memo An EIR formulated water to water heat pump model, heating operation - \min-fields 16 + \min-fields 29 A1, \field Handle \type handle \required-field From 9a435107a8c07b4a93a78edaea60b460c7d7dc2e Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Tue, 12 Sep 2023 08:07:11 -0700 Subject: [PATCH 16/18] Add and test reset curve methods. --- src/model/HeatPumpPlantLoopEIRCooling.cpp | 18 ++++++ src/model/HeatPumpPlantLoopEIRCooling.hpp | 4 ++ .../HeatPumpPlantLoopEIRCooling_Impl.hpp | 4 ++ src/model/HeatPumpPlantLoopEIRHeating.cpp | 63 +++++++++++++++++++ src/model/HeatPumpPlantLoopEIRHeating.hpp | 14 +++++ .../HeatPumpPlantLoopEIRHeating_Impl.hpp | 14 +++++ .../HeatPumpPlantLoopEIRCooling_GTest.cpp | 5 ++ .../HeatPumpPlantLoopEIRHeating_GTest.cpp | 15 +++++ 8 files changed, 137 insertions(+) diff --git a/src/model/HeatPumpPlantLoopEIRCooling.cpp b/src/model/HeatPumpPlantLoopEIRCooling.cpp index dfd901a4eac..15b7b5e475a 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling.cpp +++ b/src/model/HeatPumpPlantLoopEIRCooling.cpp @@ -366,12 +366,22 @@ namespace model { return result; } + void HeatPumpPlantLoopEIRCooling_Impl::resetMinimumSupplyWaterTemperatureCurve() { + bool result = setString(OS_HeatPump_PlantLoop_EIR_CoolingFields::MinimumSupplyWaterTemperatureCurveName, ""); + OS_ASSERT(result); + } + bool HeatPumpPlantLoopEIRCooling_Impl::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { bool result = setPointer(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurveName, maximumSupplyWaterTemperatureCurve.handle()); return result; } + void HeatPumpPlantLoopEIRCooling_Impl::resetMaximumSupplyWaterTemperatureCurve() { + bool result = setString(OS_HeatPump_PlantLoop_EIR_CoolingFields::MaximumSupplyWaterTemperatureCurveName, ""); + OS_ASSERT(result); + } + boost::optional HeatPumpPlantLoopEIRCooling_Impl::autosizedLoadSideReferenceFlowRate() const { return getAutosizedValue("Design Size Load Side Volume Flow Rate", "m3/s"); } @@ -707,10 +717,18 @@ namespace model { return getImpl()->setMinimumSupplyWaterTemperatureCurve(minimumSupplyWaterTemperatureCurve); } + void HeatPumpPlantLoopEIRCooling::resetMinimumSupplyWaterTemperatureCurve() { + getImpl()->resetMinimumSupplyWaterTemperatureCurve(); + } + bool HeatPumpPlantLoopEIRCooling::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { return getImpl()->setMaximumSupplyWaterTemperatureCurve(maximumSupplyWaterTemperatureCurve); } + void HeatPumpPlantLoopEIRCooling::resetMaximumSupplyWaterTemperatureCurve() { + getImpl()->resetMaximumSupplyWaterTemperatureCurve(); + } + boost::optional HeatPumpPlantLoopEIRCooling::autosizedLoadSideReferenceFlowRate() const { return getImpl()->autosizedLoadSideReferenceFlowRate(); } diff --git a/src/model/HeatPumpPlantLoopEIRCooling.hpp b/src/model/HeatPumpPlantLoopEIRCooling.hpp index b7784a1cfde..faf087dd33f 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling.hpp +++ b/src/model/HeatPumpPlantLoopEIRCooling.hpp @@ -136,8 +136,12 @@ namespace model { bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); + void resetMinimumSupplyWaterTemperatureCurve(); + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); + void resetMaximumSupplyWaterTemperatureCurve(); + //@} /** @name Other */ //@{ diff --git a/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp b/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp index 7f91f3e6b76..f256c6aecec 100644 --- a/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp +++ b/src/model/HeatPumpPlantLoopEIRCooling_Impl.hpp @@ -153,8 +153,12 @@ namespace model { bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); + void resetMinimumSupplyWaterTemperatureCurve(); + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); + void resetMaximumSupplyWaterTemperatureCurve(); + //@} /** @name Other */ //@{ diff --git a/src/model/HeatPumpPlantLoopEIRHeating.cpp b/src/model/HeatPumpPlantLoopEIRHeating.cpp index 80669285f3f..899d56f2b02 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.cpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.cpp @@ -429,18 +429,33 @@ namespace model { return result; } + void HeatPumpPlantLoopEIRHeating_Impl::resetMinimumSupplyWaterTemperatureCurve() { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::MinimumSupplyWaterTemperatureCurveName, ""); + OS_ASSERT(result); + } + bool HeatPumpPlantLoopEIRHeating_Impl::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumSupplyWaterTemperatureCurveName, maximumSupplyWaterTemperatureCurve.handle()); return result; } + void HeatPumpPlantLoopEIRHeating_Impl::resetMaximumSupplyWaterTemperatureCurve() { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumSupplyWaterTemperatureCurveName, ""); + OS_ASSERT(result); + } + bool HeatPumpPlantLoopEIRHeating_Impl::setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve) { bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurveName, dryOutdoorCorrectionFactorCurve.handle()); return result; } + void HeatPumpPlantLoopEIRHeating_Impl::resetDryOutdoorCorrectionFactorCurve() { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::DryOutdoorCorrectionFactorCurveName, ""); + OS_ASSERT(result); + } + bool HeatPumpPlantLoopEIRHeating_Impl::setMaximumOutdoorDryBulbTemperatureForDefrostOperation( double maximumOutdoorDryBulbTemperatureForDefrostOperation) { return setDouble(OS_HeatPump_PlantLoop_EIR_HeatingFields::MaximumOutdoorDryBulbTemperatureForDefrostOperation, @@ -463,18 +478,33 @@ namespace model { return result; } + void HeatPumpPlantLoopEIRHeating_Impl::resetDefrostEnergyInputRatioFunctionofTemperatureCurve() { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::DefrostEnergyInputRatioFunctionofTemperatureCurveName, ""); + OS_ASSERT(result); + } + bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve) { bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurveName, timedEmpiricalDefrostFrequencyCurve.handle()); return result; } + void HeatPumpPlantLoopEIRHeating_Impl::resetTimedEmpiricalDefrostFrequencyCurve() { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostFrequencyCurveName, ""); + OS_ASSERT(result); + } + bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve) { bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName, timedEmpiricalDefrostHeatLoadPenaltyCurve.handle()); return result; } + void HeatPumpPlantLoopEIRHeating_Impl::resetTimedEmpiricalDefrostHeatLoadPenaltyCurve() { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatLoadPenaltyCurveName, ""); + OS_ASSERT(result); + } + bool HeatPumpPlantLoopEIRHeating_Impl::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve( const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve) { bool result = setPointer(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName, @@ -482,6 +512,11 @@ namespace model { return result; } + void HeatPumpPlantLoopEIRHeating_Impl::resetTimedEmpiricalDefrostHeatInputEnergyFractionCurve() { + bool result = setString(OS_HeatPump_PlantLoop_EIR_HeatingFields::TimedEmpiricalDefrostHeatInputEnergyFractionCurveName, ""); + OS_ASSERT(result); + } + boost::optional HeatPumpPlantLoopEIRHeating_Impl::autosizedLoadSideReferenceFlowRate() const { return getAutosizedValue("Design Size Load Side Volume Flow Rate", "m3/s"); } @@ -875,14 +910,26 @@ namespace model { return getImpl()->setMinimumSupplyWaterTemperatureCurve(minimumSupplyWaterTemperatureCurve); } + void HeatPumpPlantLoopEIRHeating::resetMinimumSupplyWaterTemperatureCurve() { + getImpl()->resetMinimumSupplyWaterTemperatureCurve(); + } + bool HeatPumpPlantLoopEIRHeating::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) { return getImpl()->setMaximumSupplyWaterTemperatureCurve(maximumSupplyWaterTemperatureCurve); } + void HeatPumpPlantLoopEIRHeating::resetMaximumSupplyWaterTemperatureCurve() { + getImpl()->resetMaximumSupplyWaterTemperatureCurve(); + } + bool HeatPumpPlantLoopEIRHeating::setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve) { return getImpl()->setDryOutdoorCorrectionFactorCurve(dryOutdoorCorrectionFactorCurve); } + void HeatPumpPlantLoopEIRHeating::resetDryOutdoorCorrectionFactorCurve() { + getImpl()->resetDryOutdoorCorrectionFactorCurve(); + } + bool HeatPumpPlantLoopEIRHeating::setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation) { return getImpl()->setMaximumOutdoorDryBulbTemperatureForDefrostOperation( @@ -903,21 +950,37 @@ namespace model { defrostEnergyInputRatioFunctionofTemperatureCurve); } + void HeatPumpPlantLoopEIRHeating::resetDefrostEnergyInputRatioFunctionofTemperatureCurve() { + getImpl()->resetDefrostEnergyInputRatioFunctionofTemperatureCurve(); + } + bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve) { return getImpl()->setTimedEmpiricalDefrostFrequencyCurve(timedEmpiricalDefrostFrequencyCurve); } + void HeatPumpPlantLoopEIRHeating::resetTimedEmpiricalDefrostFrequencyCurve() { + getImpl()->resetTimedEmpiricalDefrostFrequencyCurve(); + } + bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve) { return getImpl()->setTimedEmpiricalDefrostHeatLoadPenaltyCurve( timedEmpiricalDefrostHeatLoadPenaltyCurve); } + void HeatPumpPlantLoopEIRHeating::resetTimedEmpiricalDefrostHeatLoadPenaltyCurve() { + getImpl()->resetTimedEmpiricalDefrostHeatLoadPenaltyCurve(); + } + bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve( const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve) { return getImpl()->setTimedEmpiricalDefrostHeatInputEnergyFractionCurve( timedEmpiricalDefrostHeatInputEnergyFractionCurve); } + void HeatPumpPlantLoopEIRHeating::resetTimedEmpiricalDefrostHeatInputEnergyFractionCurve() { + getImpl()->resetTimedEmpiricalDefrostHeatInputEnergyFractionCurve(); + } + boost::optional HeatPumpPlantLoopEIRHeating::autosizedLoadSideReferenceFlowRate() const { return getImpl()->autosizedLoadSideReferenceFlowRate(); } diff --git a/src/model/HeatPumpPlantLoopEIRHeating.hpp b/src/model/HeatPumpPlantLoopEIRHeating.hpp index 81ab04601fc..e5201985541 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.hpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.hpp @@ -160,10 +160,16 @@ namespace model { bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); + void resetMinimumSupplyWaterTemperatureCurve(); + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); + void resetMaximumSupplyWaterTemperatureCurve(); + bool setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve); + void resetDryOutdoorCorrectionFactorCurve(); + bool setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation); bool setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl); @@ -172,12 +178,20 @@ namespace model { bool setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve); + void resetDefrostEnergyInputRatioFunctionofTemperatureCurve(); + bool setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve); + void resetTimedEmpiricalDefrostFrequencyCurve(); + bool setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve); + void resetTimedEmpiricalDefrostHeatLoadPenaltyCurve(); + bool setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve); + void resetTimedEmpiricalDefrostHeatInputEnergyFractionCurve(); + //@} /** @name Other */ //@{ diff --git a/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp b/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp index 2de107b7ed6..1f87fe9c55c 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp +++ b/src/model/HeatPumpPlantLoopEIRHeating_Impl.hpp @@ -177,10 +177,16 @@ namespace model { bool setMinimumSupplyWaterTemperatureCurve(const Curve& minimumSupplyWaterTemperatureCurve); + void resetMinimumSupplyWaterTemperatureCurve(); + bool setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve); + void resetMaximumSupplyWaterTemperatureCurve(); + bool setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve); + void resetDryOutdoorCorrectionFactorCurve(); + bool setMaximumOutdoorDryBulbTemperatureForDefrostOperation(double maximumOutdoorDryBulbTemperatureForDefrostOperation); bool setHeatPumpDefrostControl(const std::string& heatPumpDefrostControl); @@ -189,12 +195,20 @@ namespace model { bool setDefrostEnergyInputRatioFunctionofTemperatureCurve(const Curve& defrostEnergyInputRatioFunctionofTemperatureCurve); + void resetDefrostEnergyInputRatioFunctionofTemperatureCurve(); + bool setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve); + void resetTimedEmpiricalDefrostFrequencyCurve(); + bool setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve); + void resetTimedEmpiricalDefrostHeatLoadPenaltyCurve(); + bool setTimedEmpiricalDefrostHeatInputEnergyFractionCurve(const Curve& timedEmpiricalDefrostHeatInputEnergyFractionCurve); + void resetTimedEmpiricalDefrostHeatInputEnergyFractionCurve(); + //@} /** @name Other */ //@{ diff --git a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp index de229d91617..06351f11417 100644 --- a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp @@ -137,6 +137,11 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_GettersSetters) { EXPECT_TRUE(hp.isLoadSideReferenceFlowRateAutosized()); EXPECT_TRUE(hp.isSourceSideReferenceFlowRateAutosized()); EXPECT_TRUE(hp.isReferenceCapacityAutosized()); + + hp.resetMinimumSupplyWaterTemperatureCurve(); + hp.resetMaximumSupplyWaterTemperatureCurve(); + EXPECT_FALSE(hp.minimumSupplyWaterTemperatureCurve()); + EXPECT_FALSE(hp.maximumSupplyWaterTemperatureCurve()); } TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_remove) { diff --git a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp index 299ddb6a5ac..8853d63e32e 100644 --- a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp @@ -178,6 +178,21 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_GettersSetters) { EXPECT_TRUE(hp.isLoadSideReferenceFlowRateAutosized()); EXPECT_TRUE(hp.isSourceSideReferenceFlowRateAutosized()); EXPECT_TRUE(hp.isReferenceCapacityAutosized()); + + hp.resetMinimumSupplyWaterTemperatureCurve(); + hp.resetMaximumSupplyWaterTemperatureCurve(); + hp.resetDryOutdoorCorrectionFactorCurve(); + hp.resetDefrostEnergyInputRatioFunctionofTemperatureCurve(); + hp.resetTimedEmpiricalDefrostFrequencyCurve(); + hp.resetTimedEmpiricalDefrostHeatLoadPenaltyCurve(); + hp.resetTimedEmpiricalDefrostHeatInputEnergyFractionCurve(); + EXPECT_FALSE(hp.minimumSupplyWaterTemperatureCurve()); + EXPECT_FALSE(hp.maximumSupplyWaterTemperatureCurve()); + EXPECT_FALSE(hp.dryOutdoorCorrectionFactorCurve()); + EXPECT_FALSE(hp.defrostEnergyInputRatioFunctionofTemperatureCurve()); + EXPECT_FALSE(hp.timedEmpiricalDefrostFrequencyCurve()); + EXPECT_FALSE(hp.timedEmpiricalDefrostHeatLoadPenaltyCurve()); + EXPECT_FALSE(hp.timedEmpiricalDefrostHeatInputEnergyFractionCurve()); } TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_remove) { From 3709fbcd910f170e5431e26238afae585adc4759 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Tue, 12 Sep 2023 10:07:03 -0700 Subject: [PATCH 17/18] Typos in heating cpp. --- src/model/HeatPumpPlantLoopEIRHeating.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/model/HeatPumpPlantLoopEIRHeating.cpp b/src/model/HeatPumpPlantLoopEIRHeating.cpp index 899d56f2b02..fed8e9c19e6 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.cpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.cpp @@ -919,7 +919,7 @@ namespace model { } void HeatPumpPlantLoopEIRHeating::resetMaximumSupplyWaterTemperatureCurve() { - getImpl()->resetMaximumSupplyWaterTemperatureCurve(); + getImpl()->resetMaximumSupplyWaterTemperatureCurve(); } bool HeatPumpPlantLoopEIRHeating::setDryOutdoorCorrectionFactorCurve(const Curve& dryOutdoorCorrectionFactorCurve) { @@ -927,7 +927,7 @@ namespace model { } void HeatPumpPlantLoopEIRHeating::resetDryOutdoorCorrectionFactorCurve() { - getImpl()->resetDryOutdoorCorrectionFactorCurve(); + getImpl()->resetDryOutdoorCorrectionFactorCurve(); } bool @@ -951,7 +951,7 @@ namespace model { } void HeatPumpPlantLoopEIRHeating::resetDefrostEnergyInputRatioFunctionofTemperatureCurve() { - getImpl()->resetDefrostEnergyInputRatioFunctionofTemperatureCurve(); + getImpl()->resetDefrostEnergyInputRatioFunctionofTemperatureCurve(); } bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostFrequencyCurve(const Curve& timedEmpiricalDefrostFrequencyCurve) { @@ -959,7 +959,7 @@ namespace model { } void HeatPumpPlantLoopEIRHeating::resetTimedEmpiricalDefrostFrequencyCurve() { - getImpl()->resetTimedEmpiricalDefrostFrequencyCurve(); + getImpl()->resetTimedEmpiricalDefrostFrequencyCurve(); } bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostHeatLoadPenaltyCurve(const Curve& timedEmpiricalDefrostHeatLoadPenaltyCurve) { @@ -968,7 +968,7 @@ namespace model { } void HeatPumpPlantLoopEIRHeating::resetTimedEmpiricalDefrostHeatLoadPenaltyCurve() { - getImpl()->resetTimedEmpiricalDefrostHeatLoadPenaltyCurve(); + getImpl()->resetTimedEmpiricalDefrostHeatLoadPenaltyCurve(); } bool HeatPumpPlantLoopEIRHeating::setTimedEmpiricalDefrostHeatInputEnergyFractionCurve( @@ -978,7 +978,7 @@ namespace model { } void HeatPumpPlantLoopEIRHeating::resetTimedEmpiricalDefrostHeatInputEnergyFractionCurve() { - getImpl()->resetTimedEmpiricalDefrostHeatInputEnergyFractionCurve(); + getImpl()->resetTimedEmpiricalDefrostHeatInputEnergyFractionCurve(); } boost::optional HeatPumpPlantLoopEIRHeating::autosizedLoadSideReferenceFlowRate() const { From 9c1449eee9b63c99f653812714d78db5ee06ad55 Mon Sep 17 00:00:00 2001 From: Julien Marrec Date: Wed, 13 Sep 2023 10:00:55 +0200 Subject: [PATCH 18/18] Fix segfault. --- src/model/HeatPumpPlantLoopEIRHeating.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/model/HeatPumpPlantLoopEIRHeating.cpp b/src/model/HeatPumpPlantLoopEIRHeating.cpp index fed8e9c19e6..3fed91b8997 100644 --- a/src/model/HeatPumpPlantLoopEIRHeating.cpp +++ b/src/model/HeatPumpPlantLoopEIRHeating.cpp @@ -911,7 +911,7 @@ namespace model { } void HeatPumpPlantLoopEIRHeating::resetMinimumSupplyWaterTemperatureCurve() { - getImpl()->resetMinimumSupplyWaterTemperatureCurve(); + getImpl()->resetMinimumSupplyWaterTemperatureCurve(); } bool HeatPumpPlantLoopEIRHeating::setMaximumSupplyWaterTemperatureCurve(const Curve& maximumSupplyWaterTemperatureCurve) {