Repository: NREL/OpenStudio (language: python)

Issue:
Update to EnergyPlus 22.2.0
Enhancement Request
--------------
Once v22.2-IOFreeze is released, we should update to it.

## Detailed Description

https://github.com/NREL/EnergyPlus/blob/develop/src/Transition/InputRulesFiles/Rules22-1-0-to-22-2-0.md

### Major changes
- [x] https://github.com/NREL/OpenStudio/issues/4647
  - https://github.com/NREL/OpenStudio/pull/4652
  - https://github.com/NREL/OpenStudio-resources/pull/173
- [x] https://github.com/NREL/OpenStudio/issues/4645
  - https://github.com/NREL/OpenStudio/pull/4672 
- [x] #4673

### New additions
- [x] https://github.com/NREL/OpenStudio/issues/4656
  - https://github.com/NREL/OpenStudio/pull/4687
  - https://github.com/NREL/OpenStudio-resources/pull/179
- [x] https://github.com/NREL/OpenStudio/issues/4648
  - https://github.com/NREL/OpenStudio/pull/4676
  - https://github.com/NREL/OpenStudio-resources/pull/177
- [x] https://github.com/NREL/OpenStudio/issues/4654
  - https://github.com/NREL/OpenStudio/pull/4676
  - https://github.com/NREL/OpenStudio-resources/pull/177
- [x] https://github.com/NREL/OpenStudio/issues/4646
  - https://github.com/NREL/OpenStudio/pull/4666
  - https://github.com/NREL/OpenStudio-resources/pull/176
- [x] https://github.com/NREL/OpenStudio/issues/4668
  - https://github.com/NREL/OpenStudio/pull/4669
- [x] https://github.com/NREL/OpenStudio/pull/4665
- [x] https://github.com/NREL/OpenStudio/pull/4661
- [x] https://github.com/NREL/OpenStudio/pull/4671
- [x] https://github.com/NREL/OpenStudio/pull/4662
- [x] https://github.com/NREL/OpenStudio/issues/4675
  - https://github.com/NREL/OpenStudio/pull/4677

### Minor stuff
- [x] `FuelFactors`: eliminate second/third input parameters.
- [x] `Construction:InternalSource`: min/max changes
- [x] `SwimmingPool:Indoor`: field `Make-up Water Supply Schedule Name` no longer required
  - 2f7a98f6cd8dd2669e48346ba59c1ebb505d07b4
- [x] https://github.com/NREL/OpenStudio/issues/4630 (could probably sneak this in)
  - https://github.com/NREL/OpenStudio/pull/4685

### Other



Discussion / hints:

Fix patch:
diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd
index b0ec1c63ebe..f3e89d6eba2 100644
--- a/resources/model/OpenStudio.idd
+++ b/resources/model/OpenStudio.idd
@@ -17615,7 +17615,10 @@ OS:Coil:Cooling:Water,
        \key CounterFlow
 
 OS:Coil:Cooling:WaterToAirHeatPump:EquationFit,
-       \Min-fields 29
+       \memo Direct expansion (DX) cooling coil for water-to-air heat pump (includes electric
+       \memo compressor), single-speed, equation-fit model. Optional inputs for moisture
+       \memo evaporation from wet coil when compressor cycles off with continuous fan operation.
+       \memo Equation-fit model uses normalized curves to describe the heat pump performance.
   A1,  \field Handle
        \type handle
        \required-field
@@ -17655,6 +17658,7 @@ OS:Coil:Cooling:WaterToAirHeatPump:EquationFit,
        \autosizable
        \default Autosize
   N3,  \field Rated Total Cooling Capacity
+       \note Total cooling capacity at rated conditions not accounting for the effect of supply air fan heat
        \type real
        \minimum> 0.0
        \units W
@@ -17667,10 +17671,35 @@ OS:Coil:Cooling:WaterToAirHeatPump:EquationFit,
        \autosizable
        \default Autosize
   N5,  \field Rated Cooling Coefficient of Performance
+       \note Gross cooling COP at rated conditions
        \type real
        \units W/W
        \minimum> 0.0
        \default 3.0
+  N6,  \field Rated Entering Water Temperature
+       \note Rated entering water temperature corresponding to the water-to
+       \note -air application for which this coil is used. For example: for water loop
+       \note applications, the rated temperature is 30 degree Celsius
+       \units C
+       \type real
+       \minimum> 0
+       \required-field
+  N7,  \field Rated Entering Air Dry-Bulb Temperature
+       \note Rated entering air dry-bulb temperature corresponding to the
+       \note water-to-air application for which this coil is used. For example: for
+       \note water loop applications, the rated temperature is 27 degree Celsius
+       \units C
+       \type real
+       \required-field
+       \minimum> 0
+  N8,  \field Rated Entering Air Wet-Bulb Temperature
+       \note Rated entering air wet-bulb temperature corresponding to the
+       \note water-to-air application for which this coil is used. For example: for
+       \note water loop applications, the rated temperature is 19 degree Celsius
+       \units C
+       \type real
+       \required-field
+       \minimum> 0
   A7,  \field Total Cooling Capacity Curve Name
        \required-field
        \type object-list
@@ -17683,7 +17712,7 @@ OS:Coil:Cooling:WaterToAirHeatPump:EquationFit,
        \required-field
        \type object-list
        \object-list QuadvariateFunctions
-  N6,  \field Nominal Time for Condensate Removal to Begin
+  N9,  \field Nominal Time for Condensate Removal to Begin
        \type real
        \units s
        \minimum 0.0
@@ -17694,7 +17723,7 @@ OS:Coil:Cooling:WaterToAirHeatPump:EquationFit,
        \note Nominal time is equal to the ratio of the energy of the coil's maximum
        \note condensate holding capacity (J) to the coil's steady state latent capacity (W).
        \note Suggested value is 1000; zero value means latent degradation model is disabled.
-  N7;  \field Ratio of Initial Moisture Evaporation Rate and Steady State Latent Capacity
+  N10; \field Ratio of Initial Moisture Evaporation Rate and Steady State Latent Capacity
        \type real
        \units dimensionless
        \minimum 0.0
@@ -18571,7 +18600,9 @@ OS:Coil:Heating:Water:Baseboard:Radiant,
       \minimum> 0.0
 
 OS:Coil:Heating:WaterToAirHeatPump:EquationFit,
-       \Min-fields 20
+       \memo Direct expansion (DX) heating coil for water-to-air heat pump (includes electric
+       \memo compressor), single-speed, equation-fit model. Equation-fit model uses normalized
+       \memo curves to describe the heat pump performance.
   A1,  \field Handle
        \type handle
        \required-field
@@ -18610,16 +18641,43 @@ OS:Coil:Heating:WaterToAirHeatPump:EquationFit,
        \autosizable
        \default Autosize
   N3,  \field Rated Heating Capacity
+       \note Heating capacity at rated conditions not accounting for the effect of supply air fan heat
        \type real
        \minimum> 0.0
        \units W
        \autosizable
        \default Autosize
   N4,  \field Rated Heating Coefficient of Performance
+       \note Gross heating COP at rated conditions
        \type real
        \minimum> 0.0
        \units W/W
        \default 3.0
+  N5,  \field Rated Entering Water Temperature
+       \note Rated entering water temperature corresponding to the water-to
+       \note -air application for which this coil is used. For example: for water loop
+       \note applications, the rated temperature is 20 degree Celsius.
+       \units C
+       \type real
+       \required-field
+  N6,  \field Rated Entering Air Dry-Bulb Temperature
+       \note Rated entering air dry-bulb temperature corresponding to the
+       \note water-to-air application for which this coil is used. For example: for
+       \note water loop applications, the rated temperature is 20 degree Celsius.
+       \units C
+       \type real
+       \required-field
+       \minimum> 0
+  N7,  \field Ratio of Rated Heating Capacity to Rated Cooling Capacity
+       \note Ratio of rated heating capacity to rated cooling capacity. This
+       \note input is used to calculate the heating or cooling capacity when autosizing.
+       \note This input is only used if a companion cooling coil of the same type
+       \note (Coil:Cooling:WaterToAirHeatPump:EquationFit) is used. This input is only
+       \note used when a sizing run for the system which uses this object is requested
+       \note and when the coil capacity is autosized.
+       \type real
+       \minimum> 0
+       \required-field
   A7,  \field Heating Capacity Curve Name
        \required-field
        \type object-list
diff --git a/src/energyplus/CMakeLists.txt b/src/energyplus/CMakeLists.txt
index 39f2dd9788d..07ff6512576 100644
--- a/src/energyplus/CMakeLists.txt
+++ b/src/energyplus/CMakeLists.txt
@@ -786,6 +786,7 @@ set(${target_name}_test_src
   Test/ZoneHVACPackagedTerminalHeatPump_GTest.cpp
   Test/ZoneHVACTerminalUnitVariableRefrigerantFlow_GTest.cpp
   Test/ZoneHVACUnitHeater_GTest.cpp
+  Test/ZoneHVACWaterToAirHeatPump_GTest.cpp
   Test/ZonePropertyUserViewFactorsBySurfaceName_GTest.cpp
   Test/ZoneVentilationWindandStackOpenArea_GTest.cpp
 )
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingWaterToAirHeatPumpEquationFit.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingWaterToAirHeatPumpEquationFit.cpp
index 75e1118df5b..3d40d1b6671 100644
--- a/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingWaterToAirHeatPumpEquationFit.cpp
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingWaterToAirHeatPumpEquationFit.cpp
@@ -69,93 +69,76 @@ namespace energyplus {
     // Object Name
     //std::string baseName = idfObject.name().get();
 
-    //  A3 ,Field Water Inlet Node Name
-
+    //  Water Inlet Node Name
     if (boost::optional<ModelObject> mo = modelObject.waterInletModelObject()) {
       if (boost::optional<Node> node = mo->optionalCast<Node>()) {
         idfObject.setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::WaterInletNodeName, node->name().get());
       }
     }
 
-    // A4, Field Water Outlet Node Name
-
+    // Water Outlet Node Name
     if (boost::optional<ModelObject> mo = modelObject.waterOutletModelObject()) {
       if (boost::optional<Node> node = mo->optionalCast<Node>()) {
         idfObject.setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::WaterOutletNodeName, node->name().get());
       }
     }
 
-    // A5, Field Air Inlet Node Name
-
+    // Air Inlet Node Name
     if (boost::optional<ModelObject> mo = modelObject.airInletModelObject()) {
       if (boost::optional<Node> node = mo->optionalCast<Node>()) {
         idfObject.setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::AirInletNodeName, node->name().get());
       }
     }
 
-    // A6 , \field Air Outlet Node Name
-
+    // Air Outlet Node Name
     if (boost::optional<ModelObject> mo = modelObject.airOutletModelObject()) {
       if (boost::optional<Node> node = mo->optionalCast<Node>()) {
         idfObject.setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::AirOutletNodeName, node->name().get());
       }
     }
 
-    // N1 Field Rated Air Flow Rate
-
-    value = modelObject.ratedAirFlowRate();
-
-    if (value) {
+    // Rated Air Flow Rate
+    if ((value = modelObject.ratedAirFlowRate())) {
       idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedAirFlowRate, *value);
-    }
-
-    else {
+    } else {
       idfObject.setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedAirFlowRate, "Autosize");
     }
 
-    //  N2 Rated Water Flow Rate
-
-    value = modelObject.ratedWaterFlowRate();
-
-    if (value) {
+    // Rated Water Flow Rate
+    if ((value = modelObject.ratedWaterFlowRate())) {
       idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedWaterFlowRate, *value);
-    }
-
-    else {
+    } else {
       idfObject.setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedWaterFlowRate, "Autosize");
     }
 
-    // N3,  Field Rated Total Cooling Capacity
-
-    value = modelObject.ratedTotalCoolingCapacity();
-
-    if (value) {
+    // Rated Total Cooling Capacity
+    if ((value = modelObject.ratedTotalCoolingCapacity())) {
       idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::GrossRatedTotalCoolingCapacity, *value);
-    }
-
-    else {
+    } else {
       idfObject.setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::GrossRatedTotalCoolingCapacity, "Autosize");
     }
 
-    // N4,  Field Rated Sensible Cooling Capacity
-
-    value = modelObject.ratedSensibleCoolingCapacity();
-
-    if (value) {
+    // Rated Sensible Cooling Capacity
+    if ((value = modelObject.ratedSensibleCoolingCapacity())) {
       idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::GrossRatedSensibleCoolingCapacity, *value);
-    }
-
-    else {
+    } else {
       idfObject.setString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::GrossRatedSensibleCoolingCapacity, "Autosize");
     }
 
-    //   N5, Field Rated Cooling Coefficient of Performance
+    // Rated Cooling Coefficient of Performance
+    idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::GrossRatedCoolingCOP, modelObject.ratedCoolingCoefficientofPerformance());
 
-    value = modelObject.ratedCoolingCoefficientofPerformance();
+    // Rated Entering Water Temperature
+    idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringWaterTemperature,
+                        modelObject.ratedEnteringWaterTemperature());
 
-    if (value) {
-      idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::GrossRatedCoolingCOP, *value);
-    }
+    // Rated Entering Air Dry-Bulb Temperature
+    idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirDryBulbTemperature,
+                        modelObject.ratedEnteringAirDryBulbTemperature());
+
+    // Rated Entering Air Wet-Bulb Temperature
+    idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirWetBulbTemperature,
+                        modelObject.ratedEnteringAirWetBulbTemperature());
 
     // Total Cooling Capacity Curve Name
     {
@@ -181,19 +164,13 @@ namespace energyplus {
       }
     }
 
-    // N22, Field Nominal Time for Condensate Removal to Begin
-
-    value = modelObject.nominalTimeforCondensateRemovaltoBegin();
-
-    if (value) {
+    // Nominal Time for Condensate Removal to Begin
+    if ((value = modelObject.nominalTimeforCondensateRemovaltoBegin())) {
       idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::NominalTimeforCondensateRemovaltoBegin, *value);
     }
 
-    //  N23, Field Ratio of Initial Moisture Evaporation Rate and Steady State Latent
-
-    value = modelObject.ratioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity();
-
-    if (value) {
+    // Ratio of Initial Moisture Evaporation Rate and Steady State Latent
+    if ((value = modelObject.ratioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity())) {
       idfObject.setDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity,
                           *value);
     }
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateCoilHeatingWaterToAirHeatPumpEquationFit.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateCoilHeatingWaterToAirHeatPumpEquationFit.cpp
index 7062470bfaf..45d207803a1 100644
--- a/src/energyplus/ForwardTranslator/ForwardTranslateCoilHeatingWaterToAirHeatPumpEquationFit.cpp
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateCoilHeatingWaterToAirHeatPumpEquationFit.cpp
@@ -82,28 +82,28 @@ namespace energyplus {
       }
     }
 
-    //Air Inlet Node Name
+    // Air Inlet Node Name
     if (boost::optional<ModelObject> mo = modelObject.airInletModelObject()) {
       if (boost::optional<Node> node = mo->optionalCast<Node>()) {
         idfObject.setString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::AirInletNodeName, node->name().get());
       }
     }
 
-    //Air Outlet Node Name
+    // Air Outlet Node Name
     if (boost::optional<ModelObject> mo = modelObject.airOutletModelObject()) {
       if (boost::optional<Node> node = mo->optionalCast<Node>()) {
         idfObject.setString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::AirOutletNodeName, node->name().get());
       }
     }
 
-    //Rated Air Flow Rate
+    // Rated Air Flow Rate
     if (modelObject.isRatedAirFlowRateAutosized()) {
       idfObject.setString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedAirFlowRate, "Autosize");
     } else if ((value = modelObject.ratedAirFlowRate())) {
       idfObject.setDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedAirFlowRate, value.get());
     }
 
-    //Rated Water Flow Rate
+    // Rated Water Flow Rate
     if (modelObject.isRatedWaterFlowRateAutosized()) {
       idfObject.setString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedWaterFlowRate, "Autosize");
     } else if ((value = modelObject.ratedWaterFlowRate())) {
@@ -118,9 +118,19 @@ namespace energyplus {
     }
 
     // Heating Coefficient of Performance
-    if ((value = modelObject.ratedHeatingCoefficientofPerformance())) {
-      idfObject.setDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::GrossRatedHeatingCOP, value.get());
-    }
+    idfObject.setDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::GrossRatedHeatingCOP, modelObject.ratedHeatingCoefficientofPerformance());
+
+    // Rated Entering Water Temperature
+    idfObject.setDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedEnteringWaterTemperature,
+                        modelObject.ratedEnteringWaterTemperature());
+
+    // Rated Entering Air Dry-Bulb Temperature
+    idfObject.setDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirDryBulbTemperature,
+                        modelObject.ratedEnteringAirDryBulbTemperature());
+
+    // Ratio of Rated Heating Capacity to Rated Cooling Capacity
+    idfObject.setDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatioofRatedHeatingCapacitytoRatedCoolingCapacity,
+                        modelObject.ratioofRatedHeatingCapacitytoRatedCoolingCapacity());
 
     // Heating Capacity Curve Name
     {
diff --git a/src/energyplus/Test/ZoneHVACWaterToAirHeatPump_GTest.cpp b/src/energyplus/Test/ZoneHVACWaterToAirHeatPump_GTest.cpp
new file mode 100644
index 00000000000..5f7bc96f598
--- /dev/null
+++ b/src/energyplus/Test/ZoneHVACWaterToAirHeatPump_GTest.cpp
@@ -0,0 +1,359 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2022, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include <gtest/gtest.h>
+#include "EnergyPlusFixture.hpp"
+
+#include "../ForwardTranslator.hpp"
+
+#include "../../model/Model.hpp"
+#include "../../model/ThermalZone.hpp"
+#include "../../model/Space.hpp"
+#include "../../model/ZoneHVACWaterToAirHeatPump.hpp"
+#include "../../model/CoilHeatingWaterToAirHeatPumpEquationFit.hpp"
+#include "../../model/CoilCoolingWaterToAirHeatPumpEquationFit.hpp"
+#include "../../model/FanOnOff.hpp"
+#include "../../model/CoilHeatingElectric.hpp"
+#include "../../model/ScheduleConstant.hpp"
+#include "../../model/PortList.hpp"
+#include "../../model/Node.hpp"
+#include "../../model/PlantLoop.hpp"
+
+#include <utilities/idd/ZoneHVAC_WaterToAirHeatPump_FieldEnums.hxx>
+#include <utilities/idd/Coil_Cooling_WaterToAirHeatPump_EquationFit_FieldEnums.hxx>
+#include <utilities/idd/Coil_Heating_WaterToAirHeatPump_EquationFit_FieldEnums.hxx>
+#include <utilities/idd/Coil_Heating_Electric_FieldEnums.hxx>
+#include <utilities/idd/Fan_OnOff_FieldEnums.hxx>
+#include <utilities/idd/OutdoorAir_Mixer_FieldEnums.hxx>
+
+#include <utilities/idd/IddEnums.hxx>
+#include "../../utilities/idf/IdfObject.hpp"
+#include "../../utilities/idf/IdfObject_Impl.hpp"
+
+#include "../../utilities/idf/WorkspaceObject.hpp"
+#include "../../utilities/idf/WorkspaceObject_Impl.hpp"
+
+using namespace openstudio::energyplus;
+using namespace openstudio::model;
+using namespace openstudio;
+
+TEST_F(EnergyPlusFixture, ForwardTranslator_ZoneHVACWaterToAirHeatPump) {
+
+  openstudio::energyplus::ForwardTranslator ft;
+
+  Model m;
+
+  Schedule sch = m.alwaysOnDiscreteSchedule();
+  sch.setName("HP AvailSch");
+  CoilHeatingWaterToAirHeatPumpEquationFit htg_coil(m);
+  htg_coil.setName("HP HC");
+  CoilCoolingWaterToAirHeatPumpEquationFit clg_coil(m);
+  clg_coil.setName("HP CC");
+  FanOnOff fan(m);
+  fan.setName("HP FanOnOff");
+  CoilHeatingElectric supp_htg_coil(m);
+  supp_htg_coil.setName("HP SupHC");
+
+  ZoneHVACWaterToAirHeatPump hp(m, sch, fan, htg_coil, clg_coil, supp_htg_coil);
+
+  EXPECT_TRUE(hp.setSupplyAirFlowRateDuringCoolingOperation(1.1));
+  EXPECT_TRUE(hp.setSupplyAirFlowRateDuringHeatingOperation(1.2));
+  EXPECT_TRUE(hp.setSupplyAirFlowRateWhenNoCoolingorHeatingisNeeded(0.5));
+
+  EXPECT_TRUE(hp.setOutdoorAirFlowRateDuringCoolingOperation(0.3));
+  EXPECT_TRUE(hp.setOutdoorAirFlowRateDuringHeatingOperation(0.4));
+  EXPECT_TRUE(hp.setOutdoorAirFlowRateWhenNoCoolingorHeatingisNeeded(0.2));
+
+  EXPECT_TRUE(hp.setMaximumCyclingRate(2.6));
+  EXPECT_TRUE(hp.setHeatPumpTimeConstant(60.1));
+  EXPECT_TRUE(hp.setFractionofOnCyclePowerUse(0.02));
+  EXPECT_TRUE(hp.setHeatPumpFanDelayTime(60.2));
+  EXPECT_TRUE(hp.setMaximumSupplyAirTemperaturefromSupplementalHeater(30.0));
+
+  EXPECT_TRUE(hp.setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(15.0));
+
+  ScheduleConstant supplyAirFanSch(m);
+  supplyAirFanSch.setName("supplyAirFanSch");
+  EXPECT_TRUE(hp.setSupplyAirFanOperatingModeSchedule(supplyAirFanSch));
+  EXPECT_TRUE(hp.setHeatPumpCoilWaterFlowMode("ConstantOnDemand"));
+
+  PlantLoop p(m);
+  EXPECT_TRUE(p.addDemandBranchForComponent(htg_coil));
+  htg_coil.waterInletModelObject()->setName("HP HC Water Inlet Node");
+  htg_coil.waterOutletModelObject()->setName("HP HC Water Outlet Node");
+  htg_coil.autosizeRatedAirFlowRate();
+  EXPECT_TRUE(htg_coil.setRatedWaterFlowRate(0.005));
+  EXPECT_TRUE(htg_coil.setRatedHeatingCapacity(8000.0));
+  EXPECT_TRUE(htg_coil.setRatedHeatingCoefficientofPerformance(3.2));
+  EXPECT_TRUE(htg_coil.setRatedEnteringWaterTemperature(21.0));
+  EXPECT_TRUE(htg_coil.setRatedEnteringAirDryBulbTemperature(19.0));
+  EXPECT_TRUE(htg_coil.setRatioofRatedHeatingCapacitytoRatedCoolingCapacity(1.1));
+
+  EXPECT_TRUE(p.addDemandBranchForComponent(clg_coil));
+  clg_coil.waterInletModelObject()->setName("HP CC Water Inlet Node");
+  clg_coil.waterOutletModelObject()->setName("HP CC Water Outlet Node");
+  EXPECT_TRUE(clg_coil.setRatedAirFlowRate(1.1));
+  EXPECT_TRUE(clg_coil.setRatedWaterFlowRate(0.004));
+  EXPECT_TRUE(clg_coil.setRatedTotalCoolingCapacity(7000.0));
+  clg_coil.autosizeRatedSensibleCoolingCapacity();
+  EXPECT_TRUE(clg_coil.setRatedCoolingCoefficientofPerformance(3.5));
+  EXPECT_TRUE(clg_coil.setRatedEnteringWaterTemperature(31.0));
+  EXPECT_TRUE(clg_coil.setRatedEnteringAirDryBulbTemperature(26.0));
+  EXPECT_TRUE(clg_coil.setRatedEnteringAirWetBulbTemperature(20.1));
+
+  ThermalZone z(m);
+  Space s(m);
+  s.setThermalZone(z);
+
+  {
+    // Not attached to a zone: not translated
+    Workspace w = ft.translateModel(m);
+
+    EXPECT_EQ(0, w.getObjectsByType(IddObjectType::ZoneHVAC_WaterToAirHeatPump).size());
+  }
+
+  // Need to be in a thermal zone to be translated, and TZ needs at least one space
+  hp.addToThermalZone(z);
+  z.inletPortList().modelObjects()[0].setName("Zone Air Inlet Node");
+  z.exhaustPortList().modelObjects()[0].setName("Zone Air Exhaust Node");
+  z.zoneAirNode().setName("Zone Air Node");
+
+  auto getObjects =
+    [](const Workspace& w) -> std::tuple<WorkspaceObject, WorkspaceObject, WorkspaceObject, WorkspaceObject, WorkspaceObject, WorkspaceObject> {
+    WorkspaceObjectVector idf_hps(w.getObjectsByType(IddObjectType::ZoneHVAC_WaterToAirHeatPump));
+    EXPECT_EQ(1, idf_hps.size());
+    WorkspaceObject idf_hp(idf_hps[0]);
+
+    auto idf_heatingCoil_ = idf_hp.getTarget(ZoneHVAC_WaterToAirHeatPumpFields::HeatingCoilName);
+
+    auto idf_coolingCoil_ = idf_hp.getTarget(ZoneHVAC_WaterToAirHeatPumpFields::CoolingCoilName);
+
+    auto idf_oamixer_ = idf_hp.getTarget(ZoneHVAC_WaterToAirHeatPumpFields::OutdoorAirMixerName);
+
+    auto idf_fan_ = idf_hp.getTarget(ZoneHVAC_WaterToAirHeatPumpFields::SupplyAirFanName);
+
+    auto idf_suppHC_ = idf_hp.getTarget(ZoneHVAC_WaterToAirHeatPumpFields::SupplementalHeatingCoilName);
+
+    return {idf_hp, idf_oamixer_.get(), idf_coolingCoil_.get(), idf_heatingCoil_.get(), idf_fan_.get(), idf_suppHC_.get()};
+  };
+
+  struct NodeNames
+  {
+    std::string zvInlet;
+    std::string zvOutlet;
+    std::string oaMixerReturnAir;
+    std::string oaMixerOutlet;
+    std::string coolingCoilInlet;
+    std::string coolingCoilOutlet;
+    std::string heatingCoilInlet;
+    std::string heatingCoilOutlet;
+    std::string fanInlet;
+    std::string fanOutlet;
+    std::string suppHeatingCoilInlet;
+    std::string suppHeatingCoilOutlet;
+  };
+
+  auto getNodeNames = [&getObjects](const Workspace& w) {
+    auto [idf_hp, idf_oamixer, idf_coolingCoil, idf_heatingCoil, idf_fan, idf_suppHC] = getObjects(w);
+
+    EXPECT_EQ(idf_heatingCoil.iddObject().type(), IddObjectType::Coil_Heating_WaterToAirHeatPump_EquationFit);
+    EXPECT_EQ(idf_coolingCoil.iddObject().type(), IddObjectType::Coil_Cooling_WaterToAirHeatPump_EquationFit);
+    EXPECT_EQ(idf_fan.iddObject().type(), IddObjectType::Fan_OnOff);
+
+    NodeNames n;
+    n.zvInlet = idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::AirInletNodeName).get();
+    n.zvOutlet = idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::AirOutletNodeName).get();
+    n.oaMixerReturnAir = idf_oamixer.getString(OutdoorAir_MixerFields::ReturnAirStreamNodeName).get();
+    n.oaMixerOutlet = idf_oamixer.getString(OutdoorAir_MixerFields::MixedAirNodeName).get();
+    n.coolingCoilInlet = idf_coolingCoil.getString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::AirInletNodeName).get();
+    n.coolingCoilOutlet = idf_coolingCoil.getString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::AirOutletNodeName).get();
+    n.heatingCoilInlet = idf_heatingCoil.getString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::AirInletNodeName).get();
+    n.heatingCoilOutlet = idf_heatingCoil.getString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::AirOutletNodeName).get();
+    n.fanInlet = idf_fan.getString(Fan_OnOffFields::AirInletNodeName).get();
+    n.fanOutlet = idf_fan.getString(Fan_OnOffFields::AirOutletNodeName).get();
+    n.suppHeatingCoilInlet = idf_suppHC.getString(Coil_Heating_ElectricFields::AirInletNodeName).get();
+    n.suppHeatingCoilOutlet = idf_suppHC.getString(Coil_Heating_ElectricFields::AirOutletNodeName).get();
+    return n;
+  };
+
+  auto validateNodeMatch = [&getNodeNames](const Workspace& w, const std::string& testName = "", bool drawThrough = true) {
+    NodeNames n = getNodeNames(w);
+    EXPECT_FALSE(n.zvInlet.empty());
+    EXPECT_FALSE(n.zvOutlet.empty());
+    EXPECT_FALSE(n.oaMixerOutlet.empty());
+    EXPECT_FALSE(n.coolingCoilInlet.empty());
+    EXPECT_FALSE(n.coolingCoilOutlet.empty());
+    EXPECT_FALSE(n.heatingCoilInlet.empty());
+    EXPECT_FALSE(n.heatingCoilOutlet.empty());
+    EXPECT_FALSE(n.fanInlet.empty());
+
+    EXPECT_EQ(n.oaMixerReturnAir, n.zvInlet) << testName << " [drawThrough=" << std::boolalpha << drawThrough
+                                             << "]: OA Mixer Return Air Strem doesn't match WAHP Inlet";
+    EXPECT_EQ("Zone Air Exhaust Node", n.zvInlet) << testName << " [drawThrough=" << std::boolalpha << drawThrough << "]: WAHP Inlet wrong name";
+    EXPECT_EQ(n.suppHeatingCoilOutlet, n.zvOutlet) << testName << " [drawThrough=" << std::boolalpha << drawThrough
+                                                   << "]: SuppHC Outlet doesn't match WAHP Outlet";
+    EXPECT_EQ("Zone Air Inlet Node", n.zvOutlet) << testName << " [drawThrough=" << std::boolalpha << drawThrough << "]: WAHP Onlet wrong name";
+
+    if (drawThrough) {
+      // o---- OA ---- CC ---- HC ---- Fan --- supHC -----o
+      EXPECT_EQ(n.oaMixerOutlet, n.coolingCoilInlet)
+        << testName << " [drawThrough=" << std::boolalpha << drawThrough << "]: OA Mixer Outlet doesn't match Cooling Coil Inlet";
+      EXPECT_EQ(n.coolingCoilOutlet, n.heatingCoilInlet)
+        << testName << " [drawThrough=" << std::boolalpha << drawThrough << "]: Cooling Outlet doesn't match Heating Coil Inlet";
+      EXPECT_EQ(n.heatingCoilOutlet, n.fanInlet) << testName << " [drawThrough=" << std::boolalpha << drawThrough
+                                                 << "]: Heating Outlet doesn't match Fan Inlet";
+      EXPECT_EQ(n.fanOutlet, n.suppHeatingCoilInlet)
+        << testName << " [drawThrough=" << std::boolalpha << drawThrough << "]: Fan Outlet doesn't match SuppHC Inlet";
+
+    } else {  // BlowThrough
+      // o---- OA ---- Fan ----- CC ---- HC ---- supHC -----o
+      EXPECT_EQ(n.oaMixerOutlet, n.fanInlet) << testName << " [drawThrough=" << std::boolalpha << drawThrough
+                                             << "]: OA Mixer Outlet doesn't match Fan Inlet";
+      EXPECT_EQ(n.fanOutlet, n.coolingCoilInlet) << testName << " [drawThrough=" << std::boolalpha << drawThrough
+                                                 << "]: Fan Outlet doesn't match Cooling Coil Inlet";
+      EXPECT_EQ(n.coolingCoilOutlet, n.heatingCoilInlet)
+        << testName << " [drawThrough=" << std::boolalpha << drawThrough << "]: Cooling Outlet doesn't match Heating Coil Inlet";
+      EXPECT_EQ(n.heatingCoilOutlet, n.suppHeatingCoilInlet)
+        << testName << " [drawThrough=" << std::boolalpha << drawThrough << "]: Heating Coil Outlet doesn't match SuppHC Inlet";
+    }
+  };
+
+  for (bool drawThrough : {true, false}) {
+
+    std::string fanPlacement = drawThrough ? "DrawThrough" : "BlowThrough";
+    EXPECT_TRUE(hp.setFanPlacement(fanPlacement));
+
+    Workspace w = ft.translateModel(m);
+
+    WorkspaceObjectVector idf_hps(w.getObjectsByType(IddObjectType::ZoneHVAC_WaterToAirHeatPump));
+    EXPECT_EQ(1, idf_hps.size());
+    WorkspaceObject& idf_hp = idf_hps.front();
+
+    ASSERT_EQ(1, w.getObjectsByType(IddObjectType::Coil_Cooling_WaterToAirHeatPump_EquationFit).size());
+    ASSERT_EQ(1, w.getObjectsByType(IddObjectType::Coil_Heating_WaterToAirHeatPump_EquationFit).size());
+    ASSERT_EQ(1, w.getObjectsByType(IddObjectType::Fan_OnOff).size());
+    ASSERT_EQ(1, w.getObjectsByType(IddObjectType::Coil_Heating_Electric).size());
+    ASSERT_EQ(1, w.getObjectsByType(IddObjectType::Zone).size());
+    ASSERT_EQ(1, w.getObjectsByType(IddObjectType::ZoneHVAC_EquipmentList).size());
+
+    validateNodeMatch(w, "", drawThrough);
+
+    EXPECT_EQ("HP AvailSch", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::AvailabilityScheduleName).get());
+    EXPECT_EQ("OutdoorAir:Mixer", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::OutdoorAirMixerObjectType).get());
+    EXPECT_EQ("Zone HVAC Water To Air Heat Pump 1 OA Mixer", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::OutdoorAirMixerName).get());
+    EXPECT_EQ(1.1, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::CoolingSupplyAirFlowRate).get());
+    EXPECT_EQ(1.2, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::HeatingSupplyAirFlowRate).get());
+    EXPECT_EQ(0.5, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::NoLoadSupplyAirFlowRate).get());
+    EXPECT_EQ(0.3, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::CoolingOutdoorAirFlowRate).get());
+    EXPECT_EQ(0.4, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::HeatingOutdoorAirFlowRate).get());
+    EXPECT_EQ(0.2, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::NoLoadOutdoorAirFlowRate).get());
+    EXPECT_EQ("Fan:OnOff", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::SupplyAirFanObjectType).get());
+    EXPECT_EQ("HP FanOnOff", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::SupplyAirFanName).get());
+    EXPECT_EQ("Coil:Heating:WaterToAirHeatPump:EquationFit", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::HeatingCoilObjectType).get());
+    EXPECT_EQ("HP HC", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::HeatingCoilName).get());
+    EXPECT_EQ("Coil:Cooling:WaterToAirHeatPump:EquationFit", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::CoolingCoilObjectType).get());
+    EXPECT_EQ("HP CC", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::CoolingCoilName).get());
+    EXPECT_EQ(2.6, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::MaximumCyclingRate).get());
+    EXPECT_EQ(60.1, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::HeatPumpTimeConstant).get());
+    EXPECT_EQ(0.02, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::FractionofOnCyclePowerUse).get());
+    EXPECT_EQ(60.2, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::HeatPumpFanDelayTime).get());
+    EXPECT_EQ("Coil:Heating:Electric", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::SupplementalHeatingCoilObjectType).get());
+    EXPECT_EQ("HP SupHC", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::SupplementalHeatingCoilName).get());
+    EXPECT_EQ(30.0, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::MaximumSupplyAirTemperaturefromSupplementalHeater).get());
+    EXPECT_EQ(15.0, idf_hp.getDouble(ZoneHVAC_WaterToAirHeatPumpFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation).get());
+    EXPECT_TRUE(idf_hp.isEmpty(ZoneHVAC_WaterToAirHeatPumpFields::OutdoorDryBulbTemperatureSensorNodeName));
+    EXPECT_EQ(fanPlacement, idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::FanPlacement).get());
+    EXPECT_EQ("supplyAirFanSch", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::SupplyAirFanOperatingModeScheduleName).get());
+    EXPECT_TRUE(idf_hp.isEmpty(ZoneHVAC_WaterToAirHeatPumpFields::AvailabilityManagerListName));
+    EXPECT_EQ("ConstantOnDemand", idf_hp.getString(ZoneHVAC_WaterToAirHeatPumpFields::HeatPumpCoilWaterFlowMode).get());
+    EXPECT_TRUE(idf_hp.isEmpty(ZoneHVAC_WaterToAirHeatPumpFields::DesignSpecificationZoneHVACSizingObjectName));
+
+    {
+      ASSERT_TRUE(idf_hp.getTarget(ZoneHVAC_WaterToAirHeatPumpFields::HeatingCoilName));
+      auto idf_heatingCoil = idf_hp.getTarget(ZoneHVAC_WaterToAirHeatPumpFields::HeatingCoilName).get();
+
+      EXPECT_EQ(htg_coil.nameString(), idf_heatingCoil.getString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::Name).get());
+      EXPECT_EQ("HP HC Water Inlet Node", idf_heatingCoil.getString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::WaterInletNodeName).get());
+      EXPECT_EQ("HP HC Water Outlet Node", idf_heatingCoil.getString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::WaterOutletNodeName).get());
+      EXPECT_EQ("Autosize", idf_heatingCoil.getString(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedAirFlowRate, false).get());
+      EXPECT_EQ(0.005, idf_heatingCoil.getDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedWaterFlowRate, false).get());
+      EXPECT_EQ(8000.0, idf_heatingCoil.getDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::GrossRatedHeatingCapacity, false).get());
+      EXPECT_EQ(3.2, idf_heatingCoil.getDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::GrossRatedHeatingCOP, false).get());
+      EXPECT_EQ(21.0, idf_heatingCoil.getDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedEnteringWaterTemperature, false).get());
+      EXPECT_EQ(19.0, idf_heatingCoil.getDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirDryBulbTemperature, false).get());
+      EXPECT_EQ(
+        1.1,
+        idf_heatingCoil.getDouble(Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatioofRatedHeatingCapacitytoRatedCoolingCapacity, false).get());
+      boost::optional<WorkspaceObject> woCurve1(
+        idf_heatingCoil.getTarget(Coil_Heating_WaterToAirHeatPump_EquationFitFields::HeatingCapacityCurveName));
+      ASSERT_TRUE(woCurve1);
+      EXPECT_EQ(woCurve1->iddObject().type(), IddObjectType::Curve_QuadLinear);
+      boost::optional<WorkspaceObject> woCurve2(
+        idf_heatingCoil.getTarget(Coil_Heating_WaterToAirHeatPump_EquationFitFields::HeatingPowerConsumptionCurveName));
+      ASSERT_TRUE(woCurve2);
+      EXPECT_EQ(woCurve2->iddObject().type(), IddObjectType::Curve_QuadLinear);
+    }
+
+    {
+      ASSERT_TRUE(idf_hp.getTarget(ZoneHVAC_WaterToAirHeatPumpFields::HeatingCoilName));
+      auto idf_coolingCoil = idf_hp.getTarget(ZoneHVAC_WaterToAirHeatPumpFields::CoolingCoilName).get();
+
+      EXPECT_EQ(clg_coil.nameString(), idf_coolingCoil.getString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::Name).get());
+      EXPECT_EQ("HP CC Water Inlet Node", idf_coolingCoil.getString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::WaterInletNodeName).get());
+      EXPECT_EQ("HP CC Water Outlet Node", idf_coolingCoil.getString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::WaterOutletNodeName).get());
+      EXPECT_EQ(1.1, idf_coolingCoil.getDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedAirFlowRate, false).get());
+      EXPECT_EQ(0.004, idf_coolingCoil.getDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedWaterFlowRate, false).get());
+      EXPECT_EQ(7000.0, idf_coolingCoil.getDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::GrossRatedTotalCoolingCapacity, false).get());
+      EXPECT_EQ("Autosize",
+                idf_coolingCoil.getString(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::GrossRatedSensibleCoolingCapacity, false).get());
+      EXPECT_EQ(3.5, idf_coolingCoil.getDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::GrossRatedCoolingCOP, false).get());
+
+      EXPECT_EQ(31.0, idf_coolingCoil.getDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringWaterTemperature, false).get());
+      EXPECT_EQ(26.0, idf_coolingCoil.getDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirDryBulbTemperature, false).get());
+      EXPECT_EQ(20.1, idf_coolingCoil.getDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirWetBulbTemperature, false).get());
+      boost::optional<WorkspaceObject> woCurve3(
+        idf_coolingCoil.getTarget(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::TotalCoolingCapacityCurveName));
+      ASSERT_TRUE(woCurve3);
+      EXPECT_EQ(woCurve3->iddObject().type(), IddObjectType::Curve_QuadLinear);
+      boost::optional<WorkspaceObject> woCurve4(
+        idf_coolingCoil.getTarget(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::SensibleCoolingCapacityCurveName));
+      ASSERT_TRUE(woCurve4);
+      EXPECT_EQ(woCurve4->iddObject().type(), IddObjectType::Curve_QuintLinear);
+      boost::optional<WorkspaceObject> woCurve5(
+        idf_coolingCoil.getTarget(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::CoolingPowerConsumptionCurveName));
+      ASSERT_TRUE(woCurve5);
+      EXPECT_EQ(woCurve5->iddObject().type(), IddObjectType::Curve_QuadLinear);
+      EXPECT_EQ(0, idf_coolingCoil.getDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::NominalTimeforCondensateRemovaltoBegin, false).get());
+      EXPECT_EQ(0.0,
+                idf_coolingCoil
+                  .getDouble(Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity)
+                  .get());
+    }
+  }
+}
diff --git a/src/model/CoilCoolingWaterToAirHeatPumpEquationFit.cpp b/src/model/CoilCoolingWaterToAirHeatPumpEquationFit.cpp
index 5a934e173e1..fb692a65464 100644
--- a/src/model/CoilCoolingWaterToAirHeatPumpEquationFit.cpp
+++ b/src/model/CoilCoolingWaterToAirHeatPumpEquationFit.cpp
@@ -191,6 +191,24 @@ namespace model {
       return isEmpty(OS_Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedCoolingCoefficientofPerformance);
     }
 
+    double CoilCoolingWaterToAirHeatPumpEquationFit_Impl::ratedEnteringWaterTemperature() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringWaterTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingWaterToAirHeatPumpEquationFit_Impl::ratedEnteringAirDryBulbTemperature() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirDryBulbTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingWaterToAirHeatPumpEquationFit_Impl::ratedEnteringAirWetBulbTemperature() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirWetBulbTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
     CurveQuadLinear CoilCoolingWaterToAirHeatPumpEquationFit_Impl::totalCoolingCapacityCurve() const {
       WorkspaceObject wo = getTarget(OS_Coil_Cooling_WaterToAirHeatPump_EquationFitFields::TotalCoolingCapacityCurveName).get();
       return wo.cast<CurveQuadLinear>();
@@ -351,6 +369,23 @@ namespace model {
       return result;
     }
 
+    bool CoilCoolingWaterToAirHeatPumpEquationFit_Impl::setRatedEnteringWaterTemperature(double ratedEnteringWaterTemperature) {
+      bool result = setDouble(OS_Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringWaterTemperature, ratedEnteringWaterTemperature);
+      return result;
+    }
+
+    bool CoilCoolingWaterToAirHeatPumpEquationFit_Impl::setRatedEnteringAirDryBulbTemperature(double ratedEnteringAirDryBulbTemperature) {
+      bool result =
+        setDouble(OS_Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirDryBulbTemperature, ratedEnteringAirDryBulbTemperature);
+      return result;
+    }
+
+    bool CoilCoolingWaterToAirHeatPumpEquationFit_Impl::setRatedEnteringAirWetBulbTemperature(double ratedEnteringAirWetBulbTemperature) {
+      bool result =
+        setDouble(OS_Coil_Cooling_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirWetBulbTemperature, ratedEnteringAirWetBulbTemperature);
+      return result;
+    }
+
     bool CoilCoolingWaterToAirHeatPumpEquationFit_Impl::setNominalTimeforCondensateRemovaltoBegin(double nominalTimeforCondensateRemovaltoBegin) {
       bool result = setDouble(OS_Coil_Cooling_WaterToAirHeatPump_EquationFitFields::NominalTimeforCondensateRemovaltoBegin,
                               nominalTimeforCondensateRemovaltoBegin);
@@ -462,7 +497,16 @@ namespace model {
     : WaterToAirComponent(CoilCoolingWaterToAirHeatPumpEquationFit::iddObjectType(), model) {
     OS_ASSERT(getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>());
 
-    bool ok = setTotalCoolingCapacityCurve(totalCoolingCapacityCurve);
+    bool ok = setRatedEnteringWaterTemperature(30);
+    OS_ASSERT(ok);
+
+    ok = setRatedEnteringAirDryBulbTemperature(27);
+    OS_ASSERT(ok);
+
+    ok = setRatedEnteringAirWetBulbTemperature(19.0);
+    OS_ASSERT(ok);
+
+    ok = setTotalCoolingCapacityCurve(totalCoolingCapacityCurve);
     OS_ASSERT(ok);
 
     ok = setSensibleCoolingCapacityCurve(sensibleCoolingCapacityCurve);
@@ -476,6 +520,15 @@ namespace model {
     : WaterToAirComponent(CoilCoolingWaterToAirHeatPumpEquationFit::iddObjectType(), model) {
     OS_ASSERT(getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>());
 
+    bool ok = setRatedEnteringWaterTemperature(30);
+    OS_ASSERT(ok);
+
+    ok = setRatedEnteringAirDryBulbTemperature(27);
+    OS_ASSERT(ok);
+
+    ok = setRatedEnteringAirWetBulbTemperature(19.0);
+    OS_ASSERT(ok);
+
     CurveQuadLinear totalCoolingCapacityCurve(model);
     totalCoolingCapacityCurve.setName("TotCoolCapCurve");
     totalCoolingCapacityCurve.setCoefficient1Constant(-0.68126221);
@@ -483,7 +536,7 @@ namespace model {
     totalCoolingCapacityCurve.setCoefficient3x(-0.93611888);
     totalCoolingCapacityCurve.setCoefficient4y(0.02081177);
     totalCoolingCapacityCurve.setCoefficient5z(0.008438868);
-    bool ok = setTotalCoolingCapacityCurve(totalCoolingCapacityCurve);
+    ok = setTotalCoolingCapacityCurve(totalCoolingCapacityCurve);
     OS_ASSERT(ok);
 
     CurveQuintLinear sensibleCoolingCapacityCurve(model);
@@ -566,6 +619,18 @@ namespace model {
     return getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->isRatedCoolingCoefficientofPerformanceDefaulted();
   }
 
+  double CoilCoolingWaterToAirHeatPumpEquationFit::ratedEnteringWaterTemperature() const {
+    return getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->ratedEnteringWaterTemperature();
+  }
+
+  double CoilCoolingWaterToAirHeatPumpEquationFit::ratedEnteringAirDryBulbTemperature() const {
+    return getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->ratedEnteringAirDryBulbTemperature();
+  }
+
+  double CoilCoolingWaterToAirHeatPumpEquationFit::ratedEnteringAirWetBulbTemperature() const {
+    return getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->ratedEnteringAirWetBulbTemperature();
+  }
+
   double CoilCoolingWaterToAirHeatPumpEquationFit::nominalTimeforCondensateRemovaltoBegin() const {
     return getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->nominalTimeforCondensateRemovaltoBegin();
   }
@@ -636,6 +701,20 @@ namespace model {
       ratedCoolingCoefficientofPerformance);
   }
 
+  bool CoilCoolingWaterToAirHeatPumpEquationFit::setRatedEnteringWaterTemperature(double ratedEnteringAirDryBulbTemperature) {
+    return getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->setRatedEnteringWaterTemperature(ratedEnteringAirDryBulbTemperature);
+  }
+
+  bool CoilCoolingWaterToAirHeatPumpEquationFit::setRatedEnteringAirDryBulbTemperature(double ratedEnteringAirDryBulbTemperature) {
+    return getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->setRatedEnteringAirDryBulbTemperature(
+      ratedEnteringAirDryBulbTemperature);
+  }
+
+  bool CoilCoolingWaterToAirHeatPumpEquationFit::setRatedEnteringAirWetBulbTemperature(double ratedEnteringAirWetBulbTemperature) {
+    return getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->setRatedEnteringAirWetBulbTemperature(
+      ratedEnteringAirWetBulbTemperature);
+  }
+
   bool CoilCoolingWaterToAirHeatPumpEquationFit::setNominalTimeforCondensateRemovaltoBegin(double nominalTimeforCondensateRemovaltoBegin) {
     return getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->setNominalTimeforCondensateRemovaltoBegin(
       nominalTimeforCondensateRemovaltoBegin);
@@ -709,9 +788,8 @@ namespace model {
   }
 
   bool CoilCoolingWaterToAirHeatPumpEquationFit::setTotalCoolingCapacityCoefficient1(double totalCoolingCapacityCoefficient1) {
-    LOG(
-      Warn,
-      "This method is deprecated. Use CoilCoolingWaterToAirHeatPumpEquationFit::totalCoolingCapacityCurve().setCoefficient1Constant(double) instead.")
+    LOG(Warn, "This method is deprecated. Use "
+              "CoilCoolingWaterToAirHeatPumpEquationFit::totalCoolingCapacityCurve().setCoefficient1Constant(double) instead.")
     CurveQuadLinear curve = getImpl<detail::CoilCoolingWaterToAirHeatPumpEquationFit_Impl>()->totalCoolingCapacityCurve();
     return curve.setCoefficient1Constant(totalCoolingCapacityCoefficient1);
   }
diff --git a/src/model/CoilCoolingWaterToAirHeatPumpEquationFit.hpp b/src/model/CoilCoolingWaterToAirHeatPumpEquationFit.hpp
index 37551e30e49..8475db9c0c5 100644
--- a/src/model/CoilCoolingWaterToAirHeatPumpEquationFit.hpp
+++ b/src/model/CoilCoolingWaterToAirHeatPumpEquationFit.hpp
@@ -94,6 +94,12 @@ namespace model {
 
     bool isRatedCoolingCoefficientofPerformanceDefaulted() const;
 
+    double ratedEnteringWaterTemperature() const;
+
+    double ratedEnteringAirDryBulbTemperature() const;
+
+    double ratedEnteringAirWetBulbTemperature() const;
+
     CurveQuadLinear totalCoolingCapacityCurve() const;
 
     OS_DEPRECATED double totalCoolingCapacityCoefficient1() const;
@@ -155,6 +161,12 @@ namespace model {
 
     bool setRatedCoolingCoefficientofPerformance(double ratedCoolingCoefficientofPerformance);
 
+    bool setRatedEnteringWaterTemperature(double ratedEnteringAirDryBulbTemperature);
+
+    bool setRatedEnteringAirDryBulbTemperature(double ratedEnteringAirDryBulbTemperature);
+
+    bool setRatedEnteringAirWetBulbTemperature(double ratedEnteringAirWetBulbTemperature);
+
     bool setTotalCoolingCapacityCurve(const CurveQuadLinear& totalCoolingCapacityCurve);
 
     OS_DEPRECATED bool setTotalCoolingCapacityCoefficient1(double totalCoolingCapacityCoefficient1);
diff --git a/src/model/CoilCoolingWaterToAirHeatPumpEquationFit_Impl.hpp b/src/model/CoilCoolingWaterToAirHeatPumpEquationFit_Impl.hpp
index b964b1cb637..4a6e70f71c5 100644
--- a/src/model/CoilCoolingWaterToAirHeatPumpEquationFit_Impl.hpp
+++ b/src/model/CoilCoolingWaterToAirHeatPumpEquationFit_Impl.hpp
@@ -111,6 +111,12 @@ namespace model {
 
       bool isRatedCoolingCoefficientofPerformanceDefaulted() const;
 
+      double ratedEnteringWaterTemperature() const;
+
+      double ratedEnteringAirDryBulbTemperature() const;
+
+      double ratedEnteringAirWetBulbTemperature() const;
+
       CurveQuadLinear totalCoolingCapacityCurve() const;
 
       CurveQuintLinear sensibleCoolingCapacityCurve() const;
@@ -167,6 +173,12 @@ namespace model {
 
       bool setRatedCoolingCoefficientofPerformance(double ratedCoolingCoefficientofPerformance);
 
+      bool setRatedEnteringWaterTemperature(double ratedEnteringAirDryBulbTemperature);
+
+      bool setRatedEnteringAirDryBulbTemperature(double ratedEnteringAirDryBulbTemperature);
+
+      bool setRatedEnteringAirWetBulbTemperature(double ratedEnteringAirWetBulbTemperature);
+
       bool setTotalCoolingCapacityCurve(const CurveQuadLinear& totalCoolingCapacityCurve);
 
       bool setSensibleCoolingCapacityCurve(const CurveQuintLinear& sensibleCoolingCapacityCurve);
diff --git a/src/model/CoilHeatingWaterToAirHeatPumpEquationFit.cpp b/src/model/CoilHeatingWaterToAirHeatPumpEquationFit.cpp
index 248ad010dd9..8abde0b847b 100644
--- a/src/model/CoilHeatingWaterToAirHeatPumpEquationFit.cpp
+++ b/src/model/CoilHeatingWaterToAirHeatPumpEquationFit.cpp
@@ -171,6 +171,25 @@ namespace model {
       return isEmpty(OS_Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedHeatingCoefficientofPerformance);
     }
 
+    double CoilHeatingWaterToAirHeatPumpEquationFit_Impl::ratedEnteringWaterTemperature() const {
+      boost::optional<double> value = getDouble(OS_Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedEnteringWaterTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilHeatingWaterToAirHeatPumpEquationFit_Impl::ratedEnteringAirDryBulbTemperature() const {
+      boost::optional<double> value = getDouble(OS_Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirDryBulbTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilHeatingWaterToAirHeatPumpEquationFit_Impl::ratioofRatedHeatingCapacitytoRatedCoolingCapacity() const {
+      boost::optional<double> value =
+        getDouble(OS_Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatioofRatedHeatingCapacitytoRatedCoolingCapacity, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
     bool CoilHeatingWaterToAirHeatPumpEquationFit_Impl::setRatedAirFlowRate(boost::optional<double> ratedAirFlowRate) {
       bool result(false);
       if (ratedAirFlowRate) {
@@ -257,6 +276,24 @@ namespace model {
       OS_ASSERT(result);
     }
 
+    bool CoilHeatingWaterToAirHeatPumpEquationFit_Impl::setRatedEnteringWaterTemperature(double ratedEnteringWaterTemperature) {
+      bool result = setDouble(OS_Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedEnteringWaterTemperature, ratedEnteringWaterTemperature);
+      return result;
+    }
+
+    bool CoilHeatingWaterToAirHeatPumpEquationFit_Impl::setRatedEnteringAirDryBulbTemperature(double ratedEnteringAirDryBulbTemperature) {
+      bool result =
+        setDouble(OS_Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatedEnteringAirDryBulbTemperature, ratedEnteringAirDryBulbTemperature);
+      return result;
+    }
+
+    bool CoilHeatingWaterToAirHeatPumpEquationFit_Impl::setRatioofRatedHeatingCapacitytoRatedCoolingCapacity(
+      double ratioofRatedHeatingCapacitytoRatedCoolingCapacity) {
+      bool result = setDouble(OS_Coil_Heating_WaterToAirHeatPump_EquationFitFields::RatioofRatedHeatingCapacitytoRatedCoolingCapacity,
+                              ratioofRatedHeatingCapacitytoRatedCoolingCapacity);
+      return result;
+    }
+
     boost::optional<HVACComponent> CoilHeatingWaterToAirHeatPumpEquationFit_Impl::containingHVACComponent() const {
       // AirLoopHVACUnitarySystem
       std::vector<AirLoopHVACUnitarySystem> airLoopHVACUnitarySystems = this->model().getConcreteModelObjects<AirLoopHVACUnitarySystem>();
@@ -354,7 +391,16 @@ namespace model {
     : WaterToAirComponent(CoilHeatingWaterToAirHeatPumpEquationFit::iddObjectType(), model) {
     OS_ASSERT(getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>());
 
-    bool ok = setHeatingCapacityCurve(heatingCapacityCurve);
+    bool ok = setRatedEnteringWaterTemperature(20);
+    OS_ASSERT(ok);
+
+    ok = setRatedEnteringAirDryBulbTemperature(20);
+    OS_ASSERT(ok);
+
+    ok = setRatioofRatedHeatingCapacitytoRatedCoolingCapacity(1.0);
+    OS_ASSERT(ok);
+
+    ok = setHeatingCapacityCurve(heatingCapacityCurve);
     OS_ASSERT(ok);
 
     ok = setHeatingPowerConsumptionCurve(heatingPowerConsumptionCurve);
@@ -366,6 +412,15 @@ namespace model {
     : WaterToAirComponent(CoilHeatingWaterToAirHeatPumpEquationFit::iddObjectType(), model) {
     OS_ASSERT(getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>());
 
+    bool ok = setRatedEnteringWaterTemperature(20);
+    OS_ASSERT(ok);
+
+    ok = setRatedEnteringAirDryBulbTemperature(20);
+    OS_ASSERT(ok);
+
+    ok = setRatioofRatedHeatingCapacitytoRatedCoolingCapacity(1.0);
+    OS_ASSERT(ok);
+
     CurveQuadLinear heatingCapacityCurve(model);
     heatingCapacityCurve.setCoefficient1Constant(-5.50102734);
     heatingCapacityCurve.setCoefficient2w(-0.96688754);
@@ -373,7 +428,7 @@ namespace model {
     heatingCapacityCurve.setCoefficient4y(0.031928881);
     heatingCapacityCurve.setCoefficient5z(0.028112522);
 
-    bool ok = setHeatingCapacityCurve(heatingCapacityCurve);
+    ok = setHeatingCapacityCurve(heatingCapacityCurve);
     OS_ASSERT(ok);
 
     CurveQuadLinear heatingPowerConsumptionCurve(model);
@@ -434,6 +489,18 @@ namespace model {
     return getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->isRatedHeatingCoefficientofPerformanceDefaulted();
   }
 
+  double CoilHeatingWaterToAirHeatPumpEquationFit::ratedEnteringWaterTemperature() const {
+    return getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->ratedEnteringWaterTemperature();
+  }
+
+  double CoilHeatingWaterToAirHeatPumpEquationFit::ratedEnteringAirDryBulbTemperature() const {
+    return getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->ratedEnteringAirDryBulbTemperature();
+  }
+
+  double CoilHeatingWaterToAirHeatPumpEquationFit::ratioofRatedHeatingCapacitytoRatedCoolingCapacity() const {
+    return getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->ratioofRatedHeatingCapacitytoRatedCoolingCapacity();
+  }
+
   bool CoilHeatingWaterToAirHeatPumpEquationFit::setRatedAirFlowRate(OptionalDouble ratedAirFlowRate) {
     return getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->setRatedAirFlowRate(ratedAirFlowRate);
   }
@@ -491,6 +558,21 @@ namespace model {
     getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->resetRatedHeatingCoefficientofPerformance();
   }
 
+  bool CoilHeatingWaterToAirHeatPumpEquationFit::setRatedEnteringWaterTemperature(double ratedEnteringWaterTemperature) {
+    return getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->setRatedEnteringWaterTemperature(ratedEnteringWaterTemperature);
+  }
+
+  bool CoilHeatingWaterToAirHeatPumpEquationFit::setRatedEnteringAirDryBulbTemperature(double ratedEnteringAirDryBulbTemperature) {
+    return getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->setRatedEnteringAirDryBulbTemperature(
+      ratedEnteringAirDryBulbTemperature);
+  }
+
+  bool CoilHeatingWaterToAirHeatPumpEquationFit::setRatioofRatedHeatingCapacitytoRatedCoolingCapacity(
+    double ratioofRatedHeatingCapacitytoRatedCoolingCapacity) {
+    return getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->setRatioofRatedHeatingCapacitytoRatedCoolingCapacity(
+      ratioofRatedHeatingCapacitytoRatedCoolingCapacity);
+  }
+
   boost::optional<double> CoilHeatingWaterToAirHeatPumpEquationFit::autosizedRatedAirFlowRate() const {
     return getImpl<detail::CoilHeatingWaterToAirHeatPumpEquationFit_Impl>()->autosizedRatedAirFlowRate();
   }
diff --git a/src/model/CoilHeatingWaterToAirHeatPumpEquationFit.hpp b/src/model/CoilHeatingWaterToAirHeatPumpEquationFit.hpp
index 2030ccf8855..4b82e04c5e6 100644
--- a/src/model/CoilHeatingWaterToAirHeatPumpEquationFit.hpp
+++ b/src/model/CoilHeatingWaterToAirHeatPumpEquationFit.hpp
@@ -91,6 +91,12 @@ namespace model {
 
     bool isRatedHeatingCoefficientofPerformanceDefaulted() const;
 
+    double ratedEnteringWaterTemperature() const;
+
+    double ratedEnteringAirDryBulbTemperature() const;
+
+    double ratioofRatedHeatingCapacitytoRatedCoolingCapacity() const;
+
     CurveQuadLinear heatingCapacityCurve() const;
 
     OS_DEPRECATED double heatingCapacityCoefficient1() const;
@@ -139,6 +145,12 @@ namespace model {
 
     void resetRatedHeatingCoefficientofPerformance();
 
+    bool setRatedEnteringWaterTemperature(double ratedEnteringWaterTemperature);
+
+    bool setRatedEnteringAirDryBulbTemperature(double ratedEnteringAirDryBulbTemperature);
+
+    bool setRatioofRatedHeatingCapacitytoRatedCoolingCapacity(double ratioofRatedHeatingCapacitytoRatedCoolingCapacity);
+
     bool setHeatingCapacityCurve(const CurveQuadLinear& heatingCapacityCurve);
 
     OS_DEPRECATED bool setHeatingCapacityCoefficient1(double heatingCapacityCoefficient1);
diff --git a/src/model/CoilHeatingWaterToAirHeatPumpEquationFit_Impl.hpp b/src/model/CoilHeatingWaterToAirHeatPumpEquationFit_Impl.hpp
index 2957b6acd61..52c6af8d23c 100644
--- a/src/model/CoilHeatingWaterToAirHeatPumpEquationFit_Impl.hpp
+++ b/src/model/CoilHeatingWaterToAirHeatPumpEquationFit_Impl.hpp
@@ -100,6 +100,12 @@ namespace model {
 
       bool isRatedHeatingCoefficientofPerformanceDefaulted() const;
 
+      double ratedEnteringWaterTemperature() const;
+
+      double ratedEnteringAirDryBulbTemperature() const;
+
+      double ratioofRatedHeatingCapacitytoRatedCoolingCapacity() const;
+
       CurveQuadLinear heatingCapacityCurve() const;
 
       CurveQuadLinear heatingPowerConsumptionCurve() const;
@@ -146,6 +152,12 @@ namespace model {
 
       void resetRatedHeatingCoefficientofPerformance();
 
+      bool setRatedEnteringWaterTemperature(double ratedEnteringWaterTemperature);
+
+      bool setRatedEnteringAirDryBulbTemperature(double ratedEnteringAirDryBulbTemperature);
+
+      bool setRatioofRatedHeatingCapacitytoRatedCoolingCapacity(double ratioofRatedHeatingCapacitytoRatedCoolingCapacity);
+
       bool setHeatingCapacityCurve(const CurveQuadLinear& heatingCapacityCurve);
 
       bool setHeatingPowerConsumptionCurve(const CurveQuadLinear& heatingPowerConsumptionCurve);
diff --git a/src/osversion/VersionTranslator.cpp b/src/osversion/VersionTranslator.cpp
index 455bb27da9c..7d184b0f2d3 100644
--- a/src/osversion/VersionTranslator.cpp
+++ b/src/osversion/VersionTranslator.cpp
@@ -7208,6 +7208,72 @@ namespace osversion {
         m_refactored.push_back(RefactoredObjectData(object, newObject));
         ss << newObject;
 
+      } else if (iddname == "OS:Coil:Heating:WaterToAirHeatPump:EquationFit") {
+
+        // Fields that have been added from 3.4.0 to 3.5.0:
+        // ------------------------------------------------
+        // * Rated Entering Water Temperature * 10
+        // * Rated Entering Air Dry-Bulb Temperature * 11
+        // * Ratio of Rated Heating Capacity to Rated Cooling Capacity * 12
+
+        auto iddObject = idd_3_5_0.getObject(iddname);
+        IdfObject newObject(iddObject.get());
+
+        for (size_t i = 0; i < object.numFields(); ++i) {
+          if ((value = object.getString(i))) {
+            if (i < 10) {
+              newObject.setString(i, value.get());
+            } else {
+              newObject.setString(i + 3, value.get());
+            }
+          }
+        }
+
+        // Rated Entering Water Temperature
+        newObject.setDouble(10, 20);
+
+        // Rated Entering Air Dry-Bulb Temperature
+        newObject.setDouble(11, 20);
+
+        // Ratio of Rated Heating Capacity to Rated Cooling Capacity
+        newObject.setDouble(12, 1.0);
+
+        m_refactored.push_back(RefactoredObjectData(object, newObject));
+        ss << newObject;
+
+      } else if (iddname == "OS:Coil:Cooling:WaterToAirHeatPump:EquationFit") {
+
+        // Fields that have been added from 3.4.0 to 3.5.0:
+        // ------------------------------------------------
+        // * Rated Entering Water Temperature * 11
+        // * Rated Entering Air Dry-Bulb Temperature * 12
+        // * Rated Entering Air Wet-Bulb Temperature * 13
+
+        auto iddObject = idd_3_5_0.getObject(iddname);
+        IdfObject newObject(iddObject.get());
+
+        for (size_t i = 0; i < object.numFields(); ++i) {
+          if ((value = object.getString(i))) {
+            if (i < 11) {
+              newObject.setString(i, value.get());
+            } else {
+              newObject.setString(i + 3, value.get());
+            }
+          }
+        }
+
+        // Rated Entering Water Temperature
+        newObject.setDouble(11, 30);
+
+        // Rated Entering Air Dry-Bulb Temperature
+        newObject.setDouble(12, 27);
+
+        // Rated Entering Air Wet-Bulb Temperature
+        newObject.setDouble(13, 19.0);
+
+        m_refactored.push_back(RefactoredObjectData(object, newObject));
+        ss << newObject;
+
         // No-op
       } else {
         ss << object;


Test patch:
diff --git a/src/model/test/CoilCoolingWaterToAirHeatPumpEquationFit_GTest.cpp b/src/model/test/CoilCoolingWaterToAirHeatPumpEquationFit_GTest.cpp
index a2ffcd40a77..71e4af4b4e8 100644
--- a/src/model/test/CoilCoolingWaterToAirHeatPumpEquationFit_GTest.cpp
+++ b/src/model/test/CoilCoolingWaterToAirHeatPumpEquationFit_GTest.cpp
@@ -168,6 +168,19 @@ TEST_F(ModelFixture, CoilCoolingWaterToAirHeatPumpEquationFit_Check_Getters_and_
   boost::optional<double> testRatedCoolingCoefficientofPerformance = coilCoolingWaterToAirHeatPumpEquationFit.ratedCoolingCoefficientofPerformance();
   EXPECT_EQ((*testRatedCoolingCoefficientofPerformance), 100);
 
+  // Test Rated Entering Water, Air Dry-Bulb, Air Wet-Bulb Temperature
+  EXPECT_EQ(30, coilCoolingWaterToAirHeatPumpEquationFit.ratedEnteringWaterTemperature());
+  EXPECT_TRUE(coilCoolingWaterToAirHeatPumpEquationFit.setRatedEnteringWaterTemperature(35));
+  EXPECT_EQ(35, coilCoolingWaterToAirHeatPumpEquationFit.ratedEnteringWaterTemperature());
+
+  EXPECT_EQ(27, coilCoolingWaterToAirHeatPumpEquationFit.ratedEnteringAirDryBulbTemperature());
+  EXPECT_TRUE(coilCoolingWaterToAirHeatPumpEquationFit.setRatedEnteringAirDryBulbTemperature(22));
+  EXPECT_EQ(22, coilCoolingWaterToAirHeatPumpEquationFit.ratedEnteringAirDryBulbTemperature());
+
+  EXPECT_EQ(19.0, coilCoolingWaterToAirHeatPumpEquationFit.ratedEnteringAirWetBulbTemperature());
+  EXPECT_TRUE(coilCoolingWaterToAirHeatPumpEquationFit.setRatedEnteringAirWetBulbTemperature(18.6));
+  EXPECT_EQ(18.6, coilCoolingWaterToAirHeatPumpEquationFit.ratedEnteringAirWetBulbTemperature());
+
   // Fields N6 - N10 Check set Cooling Capacity Coefficients
   coilCoolingWaterToAirHeatPumpEquationFit.setTotalCoolingCapacityCoefficient1(1);
   double testTotalCoolingCapacityCoefficient1 = coilCoolingWaterToAirHeatPumpEquationFit.totalCoolingCapacityCoefficient1();
diff --git a/src/model/test/CoilHeatingWaterToAirHeatPumpEquationFit_GTest.cpp b/src/model/test/CoilHeatingWaterToAirHeatPumpEquationFit_GTest.cpp
index 0a4c9371be0..125d813625d 100644
--- a/src/model/test/CoilHeatingWaterToAirHeatPumpEquationFit_GTest.cpp
+++ b/src/model/test/CoilHeatingWaterToAirHeatPumpEquationFit_GTest.cpp
@@ -88,4 +88,19 @@ TEST_F(ModelFixture, CoilHeatingWaterToAirHeatPumpEquationFit_Test) {
   coilHeatingWaterToAirHPEquationFit.resetRatedHeatingCoefficientofPerformance();
   EXPECT_TRUE(coilHeatingWaterToAirHPEquationFit.ratedHeatingCoefficientofPerformance());
   EXPECT_TRUE(coilHeatingWaterToAirHPEquationFit.isRatedHeatingCoefficientofPerformanceDefaulted());
+
+  // test rated entering water temperature
+  EXPECT_EQ(20, coilHeatingWaterToAirHPEquationFit.ratedEnteringWaterTemperature());
+  EXPECT_TRUE(coilHeatingWaterToAirHPEquationFit.setRatedEnteringWaterTemperature(25));
+  EXPECT_EQ(25, coilHeatingWaterToAirHPEquationFit.ratedEnteringWaterTemperature());
+
+  // test rated entering air dry bulb temperature
+  EXPECT_EQ(20, coilHeatingWaterToAirHPEquationFit.ratedEnteringAirDryBulbTemperature());
+  EXPECT_TRUE(coilHeatingWaterToAirHPEquationFit.setRatedEnteringAirDryBulbTemperature(26));
+  EXPECT_EQ(26, coilHeatingWaterToAirHPEquationFit.ratedEnteringAirDryBulbTemperature());
+
+  // test ratio of rated heating capacity to rated cooling capacity
+  EXPECT_EQ(1.0, coilHeatingWaterToAirHPEquationFit.ratioofRatedHeatingCapacitytoRatedCoolingCapacity());
+  EXPECT_TRUE(coilHeatingWaterToAirHPEquationFit.setRatioofRatedHeatingCapacitytoRatedCoolingCapacity(1.2));
+  EXPECT_EQ(1.2, coilHeatingWaterToAirHPEquationFit.ratioofRatedHeatingCapacitytoRatedCoolingCapacity());
 }
diff --git a/src/osversion/test/3_5_0/test_vt_CoilCoolingWaterToAirHeatPumpEquationFit.osm b/src/osversion/test/3_5_0/test_vt_CoilCoolingWaterToAirHeatPumpEquationFit.osm
new file mode 100644
index 00000000000..9ed0240a4f7
--- /dev/null
+++ b/src/osversion/test/3_5_0/test_vt_CoilCoolingWaterToAirHeatPumpEquationFit.osm
@@ -0,0 +1,77 @@
+
+OS:Version,
+  {5e239450-9777-465b-b188-ac931373642f}, !- Handle
+  3.4.0;                                  !- Version Identifier
+
+OS:Coil:Cooling:WaterToAirHeatPump:EquationFit,
+  {49f0b93d-e54e-42f4-ae66-16060ef93e1e}, !- Handle
+  Coil Cooling Water To Air Heat Pump Equation Fit 1, !- Name
+  ,                                       !- Water Inlet Node Name
+  ,                                       !- Water Outlet Node Name
+  ,                                       !- Air Inlet Node Name
+  ,                                       !- Air Outlet Node Name
+  ,                                       !- Rated Air Flow Rate {m3/s}
+  ,                                       !- Rated Water Flow Rate {m3/s}
+  ,                                       !- Rated Total Cooling Capacity {W}
+  ,                                       !- Rated Sensible Cooling Capacity {W}
+  ,                                       !- Rated Cooling Coefficient of Performance {W/W}
+  {88c5ef9e-f97b-4a0a-8028-ef6d418d7635}, !- Total Cooling Capacity Curve Name
+  {3cfae2f4-8ac2-4dfc-9ced-08c224c8a3f1}, !- Sensible Cooling Capacity Curve Name
+  {cb515806-7299-42e5-91ec-994aaa91ae37}, !- Cooling Power Consumption Curve Name
+  ,                                       !- Nominal Time for Condensate Removal to Begin {s}
+  ;                                       !- Ratio of Initial Moisture Evaporation Rate and Steady State Latent Capacity {dimensionless}
+
+OS:Curve:QuadLinear,
+  {88c5ef9e-f97b-4a0a-8028-ef6d418d7635}, !- Handle
+  TotCoolCapCurve,                        !- Name
+  -0.68126221,                            !- Coefficient1 Constant
+  1.99529297,                             !- Coefficient2 w
+  -0.93611888,                            !- Coefficient3 x
+  0.02081177,                             !- Coefficient4 y
+  0.008438868,                            !- Coefficient5 z
+  -100,                                   !- Minimum Value of w {BasedOnField A2}
+  100,                                    !- Maximum Value of w {BasedOnField A2}
+  -100,                                   !- Minimum Value of x {BasedOnField A3}
+  100,                                    !- Maximum Value of x {BasedOnField A3}
+  0,                                      !- Minimum Value of y {BasedOnField A4}
+  100,                                    !- Maximum Value of y {BasedOnField A4}
+  0,                                      !- Minimum Value of z {BasedOnField A5}
+  100;                                    !- Maximum Value of z {BasedOnField A5}
+
+OS:Curve:QuintLinear,
+  {3cfae2f4-8ac2-4dfc-9ced-08c224c8a3f1}, !- Handle
+  Curve Quint Linear 1,                   !- Name
+  2.24209455,                             !- Coefficient1 Constant
+  7.28913391,                             !- Coefficient2 v
+  -9.06079896,                            !- Coefficient3 w
+  -0.36729404,                            !- Coefficient4 x
+  0.218826161,                            !- Coefficient5 y
+  0.00901534,                             !- Coefficient6 z
+  -100,                                   !- Minimum Value of v {BasedOnField A2}
+  100,                                    !- Maximum Value of v {BasedOnField A2}
+  -100,                                   !- Minimum Value of w {BasedOnField A2}
+  100,                                    !- Maximum Value of w {BasedOnField A2}
+  -100,                                   !- Minimum Value of x {BasedOnField A3}
+  100,                                    !- Maximum Value of x {BasedOnField A3}
+  0,                                      !- Minimum Value of y {BasedOnField A4}
+  100,                                    !- Maximum Value of y {BasedOnField A4}
+  0,                                      !- Minimum Value of z {BasedOnField A5}
+  100;                                    !- Maximum Value of z {BasedOnField A5}
+
+OS:Curve:QuadLinear,
+  {cb515806-7299-42e5-91ec-994aaa91ae37}, !- Handle
+  Curve Quad Linear 1,                    !- Name
+  -3.20456384,                            !- Coefficient1 Constant
+  0.47656454,                             !- Coefficient2 w
+  3.16734236,                             !- Coefficient3 x
+  0.10244637,                             !- Coefficient4 y
+  -0.038132556,                           !- Coefficient5 z
+  -100,                                   !- Minimum Value of w {BasedOnField A2}
+  100,                                    !- Maximum Value of w {BasedOnField A2}
+  -100,                                   !- Minimum Value of x {BasedOnField A3}
+  100,                                    !- Maximum Value of x {BasedOnField A3}
+  0,                                      !- Minimum Value of y {BasedOnField A4}
+  100,                                    !- Maximum Value of y {BasedOnField A4}
+  0,                                      !- Minimum Value of z {BasedOnField A5}
+  100;                                    !- Maximum Value of z {BasedOnField A5}
+
diff --git a/src/osversion/test/3_5_0/test_vt_CoilHeatingWaterToAirHeatPumpEquationFit.osm b/src/osversion/test/3_5_0/test_vt_CoilHeatingWaterToAirHeatPumpEquationFit.osm
new file mode 100644
index 00000000000..c1758cffaab
--- /dev/null
+++ b/src/osversion/test/3_5_0/test_vt_CoilHeatingWaterToAirHeatPumpEquationFit.osm
@@ -0,0 +1,53 @@
+
+OS:Version,
+  {17b436f0-e1e5-4fcb-a077-ac1e20ff3e1e}, !- Handle
+  3.4.0;                                  !- Version Identifier
+
+OS:Coil:Heating:WaterToAirHeatPump:EquationFit,
+  {475386b1-8e5b-4997-a347-64b3e7327bc0}, !- Handle
+  Coil Heating Water To Air Heat Pump Equation Fit 1, !- Name
+  ,                                       !- Water Inlet Node Name
+  ,                                       !- Water Outlet Node Name
+  ,                                       !- Air Inlet Node Name
+  ,                                       !- Air Outlet Node Name
+  ,                                       !- Rated Air Flow Rate {m3/s}
+  ,                                       !- Rated Water Flow Rate {m3/s}
+  ,                                       !- Rated Heating Capacity {W}
+  ,                                       !- Rated Heating Coefficient of Performance {W/W}
+  {25a5aeb1-b534-48fe-bcc6-5364385b9280}, !- Heating Capacity Curve Name
+  {83b26ab1-9da5-42a1-bb76-fcf0769f1cae}; !- Heating Power Consumption Curve Name
+
+OS:Curve:QuadLinear,
+  {25a5aeb1-b534-48fe-bcc6-5364385b9280}, !- Handle
+  Curve Quad Linear 1,                    !- Name
+  -5.50102734,                            !- Coefficient1 Constant
+  -0.96688754,                            !- Coefficient2 w
+  7.70755007,                             !- Coefficient3 x
+  0.031928881,                            !- Coefficient4 y
+  0.028112522,                            !- Coefficient5 z
+  -100,                                   !- Minimum Value of w {BasedOnField A2}
+  100,                                    !- Maximum Value of w {BasedOnField A2}
+  -100,                                   !- Minimum Value of x {BasedOnField A3}
+  100,                                    !- Maximum Value of x {BasedOnField A3}
+  0,                                      !- Minimum Value of y {BasedOnField A4}
+  100,                                    !- Maximum Value of y {BasedOnField A4}
+  0,                                      !- Minimum Value of z {BasedOnField A5}
+  100;                                    !- Maximum Value of z {BasedOnField A5}
+
+OS:Curve:QuadLinear,
+  {83b26ab1-9da5-42a1-bb76-fcf0769f1cae}, !- Handle
+  Curve Quad Linear 2,                    !- Name
+  -7.47517858,                            !- Coefficient1 Constant
+  6.40876653,                             !- Coefficient2 w
+  1.99711665,                             !- Coefficient3 x
+  -0.050682973,                           !- Coefficient4 y
+  0.011385145,                            !- Coefficient5 z
+  -100,                                   !- Minimum Value of w {BasedOnField A2}
+  100,                                    !- Maximum Value of w {BasedOnField A2}
+  -100,                                   !- Minimum Value of x {BasedOnField A3}
+  100,                                    !- Maximum Value of x {BasedOnField A3}
+  0,                                      !- Minimum Value of y {BasedOnField A4}
+  100,                                    !- Maximum Value of y {BasedOnField A4}
+  0,                                      !- Minimum Value of z {BasedOnField A5}
+  100;                                    !- Maximum Value of z {BasedOnField A5}
+
diff --git a/src/osversion/test/3_5_0/test_vt_EquationFitCoils.rb b/src/osversion/test/3_5_0/test_vt_EquationFitCoils.rb
new file mode 100644
index 00000000000..5f55918cb66
--- /dev/null
+++ b/src/osversion/test/3_5_0/test_vt_EquationFitCoils.rb
@@ -0,0 +1,18 @@
+#require '/usr/local/openstudio-3.4.0/Ruby/openstudio'
+
+include OpenStudio::Model
+
+def test_vt_CoilHeatingWaterToAirHeatPumpEquationFit
+  m = Model.new
+  ch = CoilHeatingWaterToAirHeatPumpEquationFit.new(m)
+  m.save('test_vt_CoilHeatingWaterToAirHeatPumpEquationFit.osm')
+end
+
+def test_vt_CoilCoolingWaterToAirHeatPumpEquationFit
+  m = Model.new
+  cc = CoilCoolingWaterToAirHeatPumpEquationFit.new(m)
+  m.save('test_vt_CoilCoolingWaterToAirHeatPumpEquationFit.osm')
+end
+
+test_vt_CoilHeatingWaterToAirHeatPumpEquationFit()
+test_vt_CoilCoolingWaterToAirHeatPumpEquationFit()
diff --git a/src/osversion/test/VersionTranslator_GTest.cpp b/src/osversion/test/VersionTranslator_GTest.cpp
index ed1289d6d94..dc3c8571fc6 100644
--- a/src/osversion/test/VersionTranslator_GTest.cpp
+++ b/src/osversion/test/VersionTranslator_GTest.cpp
@@ -1399,10 +1399,12 @@ TEST_F(OSVersionFixture, update_3_1_0_to_3_2_0_CoilCoolingWaterToAirHeatPumpEqua
   // Field before: Rated COP
   EXPECT_EQ(4.2, coil.getDouble(10).get());
 
+  // 3.4.0 to 3.5.0: (3) fields added
+
   // Curves
   {
-    ASSERT_TRUE(coil.getTarget(11));
-    WorkspaceObject totalCoolingCapacityCurve = coil.getTarget(11).get();
+    ASSERT_TRUE(coil.getTarget(14));
+    WorkspaceObject totalCoolingCapacityCurve = coil.getTarget(14).get();
     EXPECT_EQ(coil.nameString() + " TotCoolCapCurve", totalCoolingCapacityCurve.nameString());
 
     EXPECT_EQ(-0.68126221, totalCoolingCapacityCurve.getDouble(2).get());
@@ -1421,8 +1423,8 @@ TEST_F(OSVersionFixture, update_3_1_0_to_3_2_0_CoilCoolingWaterToAirHeatPumpEqua
   }
 
   {
-    ASSERT_TRUE(coil.getTarget(12));
-    WorkspaceObject sensibleCoolingCapacityCurve = coil.getTarget(12).get();
+    ASSERT_TRUE(coil.getTarget(15));
+    WorkspaceObject sensibleCoolingCapacityCurve = coil.getTarget(15).get();
     // This is a CurveQuintLinear
     EXPECT_EQ(coil.nameString() + " SensCoolCapCurve", sensibleCoolingCapacityCurve.nameString());
     EXPECT_EQ(2.24209455, sensibleCoolingCapacityCurve.getDouble(2).get());
@@ -1444,8 +1446,8 @@ TEST_F(OSVersionFixture, update_3_1_0_to_3_2_0_CoilCoolingWaterToAirHeatPumpEqua
   }
 
   {
-    ASSERT_TRUE(coil.getTarget(13));
-    WorkspaceObject coolingPowerConsumptionCurve = coil.getTarget(13).get();
+    ASSERT_TRUE(coil.getTarget(16));
+    WorkspaceObject coolingPowerConsumptionCurve = coil.getTarget(16).get();
     EXPECT_EQ(coil.nameString() + " CoolPowCurve", coolingPowerConsumptionCurve.nameString());
     EXPECT_EQ(-3.20456384, coolingPowerConsumptionCurve.getDouble(2).get());
     EXPECT_EQ(0.47656454, coolingPowerConsumptionCurve.getDouble(3).get());
@@ -1463,10 +1465,10 @@ TEST_F(OSVersionFixture, update_3_1_0_to_3_2_0_CoilCoolingWaterToAirHeatPumpEqua
   }
 
   // Field after: Nominal Time for Condensate Removal to Begin
-  EXPECT_EQ(360.0, coil.getDouble(14).get());
+  EXPECT_EQ(360.0, coil.getDouble(17).get());
 
   // Last field
-  EXPECT_EQ(0.1, coil.getDouble(15).get());
+  EXPECT_EQ(0.1, coil.getDouble(18).get());
 }
 
 TEST_F(OSVersionFixture, update_3_1_0_to_3_2_0_CoilHeatingWaterToAirHeatPumpEquationFit) {
@@ -1485,10 +1487,12 @@ TEST_F(OSVersionFixture, update_3_1_0_to_3_2_0_CoilHeatingWaterToAirHeatPumpEqua
   // Field before: Rated COP
   EXPECT_EQ(4.5, coil.getDouble(9).get());
 
+  // 3.5.0 to 3.5.0: (3) fields added
+
   // Curves
   {
-    ASSERT_TRUE(coil.getTarget(10));
-    WorkspaceObject heatingCapacityCurve = coil.getTarget(10).get();
+    ASSERT_TRUE(coil.getTarget(13));
+    WorkspaceObject heatingCapacityCurve = coil.getTarget(13).get();
     EXPECT_EQ(coil.nameString() + " HeatCapCurve", heatingCapacityCurve.nameString());
     EXPECT_EQ(-5.50102734, heatingCapacityCurve.getDouble(2).get());
     EXPECT_EQ(-0.96688754, heatingCapacityCurve.getDouble(3).get());
@@ -1506,11 +1510,9 @@ TEST_F(OSVersionFixture, update_3_1_0_to_3_2_0_CoilHeatingWaterToAirHeatPumpEqua
   }
 
   {
-    ASSERT_TRUE(coil.getTarget(11));
-    WorkspaceObject heatingPowerConsumptionCurve = coil.getTarget(11).get();
-
+    ASSERT_TRUE(coil.getTarget(14));
+    WorkspaceObject heatingPowerConsumptionCurve = coil.getTarget(14).get();
     EXPECT_EQ(coil.nameString() + " HeatPowCurve", heatingPowerConsumptionCurve.nameString());
-
     EXPECT_EQ(-7.47517858, heatingPowerConsumptionCurve.getDouble(2).get());
     EXPECT_EQ(6.40876653, heatingPowerConsumptionCurve.getDouble(3).get());
     EXPECT_EQ(1.99711665, heatingPowerConsumptionCurve.getDouble(4).get());
@@ -2099,3 +2101,44 @@ TEST_F(OSVersionFixture, update_3_4_0_to_3_5_0_CoilCoolingDXCurveFitSpeed) {
   EXPECT_EQ(773.3, coil.getDouble(8).get());  // Rated Evaporator Fan Power Per Volume Flow Rate 2017
   EXPECT_EQ(934.4, coil.getDouble(9).get());  // Rated Evaporator Fan Power Per Volume Flow Rate 2023
 }
+
+TEST_F(OSVersionFixture, update_3_4_0_to_3_5_0_CoilHeatingWaterToAirHeatPumpEquationFit) {
+  openstudio::path path = resourcesPath() / toPath("osversion/3_5_0/test_vt_CoilHeatingWaterToAirHeatPumpEquationFit.osm");
+  osversion::VersionTranslator vt;
+  boost::optional<model::Model> model = vt.loadModel(path);
+  ASSERT_TRUE(model) << "Failed to load " << path;
+
+  openstudio::path outPath = resourcesPath() / toPath("osversion/3_5_0/test_vt_CoilHeatingWaterToAirHeatPumpEquationFit_updated.osm");
+  model->save(outPath, true);
+
+  std::vector<WorkspaceObject> coils = model->getObjectsByType("OS:Coil:Heating:WaterToAirHeatPump:EquationFit");
+  ASSERT_EQ(1u, coils.size());
+  WorkspaceObject coil = coils[0];
+
+  EXPECT_TRUE(coil.isEmpty(9));              // Rated Heating Coefficient of Performance
+  EXPECT_EQ(20, coil.getDouble(10).get());   // Rated Entering Water Temperature
+  EXPECT_EQ(20, coil.getDouble(11).get());   // Rated Entering Air Dry-Bulb Temperature
+  EXPECT_EQ(1.0, coil.getDouble(12).get());  // Ratio of Rated Heating Capacity to Rated Cooling Capacity
+  ASSERT_TRUE(coil.getTarget(14));           // Heating Power Consumption Curve Name
+  EXPECT_EQ("Curve Quad Linear 2", coil.getTarget(14)->nameString());
+}
+
+TEST_F(OSVersionFixture, update_3_4_0_to_3_5_0_CoilCoolingWaterToAirHeatPumpEquationFit) {
+  openstudio::path path = resourcesPath() / toPath("osversion/3_5_0/test_vt_CoilCoolingWaterToAirHeatPumpEquationFit.osm");
+  osversion::VersionTranslator vt;
+  boost::optional<model::Model> model = vt.loadModel(path);
+  ASSERT_TRUE(model) << "Failed to load " << path;
+
+  openstudio::path outPath = resourcesPath() / toPath("osversion/3_5_0/test_vt_CoilCoolingWaterToAirHeatPumpEquationFit_updated.osm");
+  model->save(outPath, true);
+
+  std::vector<WorkspaceObject> coils = model->getObjectsByType("OS:Coil:Cooling:WaterToAirHeatPump:EquationFit");
+  ASSERT_EQ(1u, coils.size());
+  WorkspaceObject coil = coils[0];
+
+  EXPECT_TRUE(coil.isEmpty(10));              // Rated Cooling Coefficient of Performance
+  EXPECT_EQ(30, coil.getDouble(11).get());    // Rated Entering Water Temperature
+  EXPECT_EQ(27, coil.getDouble(12).get());    // Rated Entering Air Dry-Bulb Temperature
+  EXPECT_EQ(19.0, coil.getDouble(13).get());  // Rated Entering Air Wet-Bulb Temperature
+  EXPECT_TRUE(coil.isEmpty(18));              // Ratio of Initial Moisture Evaporation Rate and Steady State Latent Capacity
+}