Repository: NREL/OpenStudio (language: python)

Issue:
E+ 23.1.0: Wrap Gas-Fired Absorption Heat Pump (GAHP)
Enhancement Request
--------------

Wrap the new GAHP once https://github.com/NREL/EnergyPlus/pull/9405 is merged.



Discussion / hints:
`StraightComponent`, like `CoolingTower:SingleSpeed`?

Fix patch:
diff --git a/resources/energyplus/ProposedEnergy+.idd b/resources/energyplus/ProposedEnergy+.idd
index edbfb52d803..7dca33e2b20 100644
--- a/resources/energyplus/ProposedEnergy+.idd
+++ b/resources/energyplus/ProposedEnergy+.idd
@@ -44493,6 +44493,336 @@ HeatPump:PlantLoop:EIR:Heating,
         \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)
 
+HeatPump:AirToWater:FuelFired:Heating,
+       \memo The object defines a fuel-fired absorption heat pump based on equation-fit models.
+       \min-fields 31
+  A1 , \field Name
+       \required-field
+       \reference HeatPumpAirToWaterFuelFiredHeatingNames
+       \note Name of the fuel fired absorption heat pump system system
+       \reference-class-name validPlantEquipmentTypes
+       \reference validPlantEquipmentNames
+       \reference-class-name validBranchEquipmentTypes
+       \reference validBranchEquipmentNames
+  A2 , \field Water Inlet Node Name
+       \required-field
+       \type node
+       \note Inlet node name of the water side connection
+  A3 , \field Water Outlet Node Name
+       \required-field
+       \type node
+       \note Outlet node name of the water side connection
+  A4 , \field Air Source Node Name
+       \type object-list
+       \object-list OutdoorAirNodeNames
+       \note This is the air source node name, which is the evaporator side of the heat pump in heating mode.
+       \note Enter the name of an OutdoorAir:Node object.
+  A5 , \field Companion Cooling Heat Pump Name
+       \note The name of the companion HeatPump:AirToWater:FuelFired:Cooling object
+       \note This field is used for a heat pump with switchable heating and cooling mode.
+       \type object-list
+       \object-list HeatPumpAirToWaterFuelFiredCoolingNames
+  A6 , \field Fuel Type
+       \type choice
+       \key NaturalGas
+       \key Propane
+       \key FuelOilNo1
+       \key FuelOilNo2
+       \key Diesel
+       \key Gasoline
+       \key Coal
+       \key OtherFuel1
+       \key OtherFuel2
+       \default NaturalGas
+       \note Fuel Type (NaturalGas, Propane, Gasoline, Diesel etc.)
+  A7 , \field End-Use Subcategory
+       \type alpha
+       \retaincase
+       \default General
+       \note Any text may be used here to categorize the end-uses in the ABUPS End Uses by Subcategory table.
+  N1 , \field Nominal Heating Capacity
+       \autosizable
+       \minimum> 0
+       \units W
+       \note Nominal Heating Capacity in [W] (autosizeable)
+  N2 , \field Nominal COP
+       \type real
+       \minimum> 0
+       \default 1.0
+       \units W/W
+       \note Nominal COP (Coefficient of Performance)
+  N3 , \field Design Flow Rate
+       \autosizable
+       \minimum> 0
+       \units m3/s
+       \note Design Flow Rate in m3/s (autosizeable)
+  N4 , \field Design Supply Temperature
+       \default 60
+       \units C
+       \note Design Supply Temperature in [degree C]
+  N5 , \field Design Temperature Lift
+       \autosizable
+       \default 11.1
+       \units deltaC
+       \note Design Temperature Lift in [degree C]
+  N6 , \field Sizing Factor
+       \minimum 1.0
+       \default 1.0
+       \note Sizing Factor for equipment sizing
+  A8 , \field Flow Mode
+       \type choice
+       \key NotModulated
+       \key ConstantFlow
+       \key LeavingSetpointModulated
+       \default NotModulated
+       \note Flow Mode for the water side of the fuel-fired absorption heat pump
+  A9 , \field Outdoor Air Temperature Curve Input Variable
+       \type choice
+       \key DryBulb
+       \key WetBulb
+       \default DryBulb
+       \note Outdoor air temperature curve input variable;
+       \note The options are Outdoor Air Dry Bulb or Wet Bulb temperature for curves
+  A10, \field Water Temperature Curve Input Variable
+       \type choice
+       \key EnteringCondenser
+       \key LeavingCondenser
+       \default EnteringCondenser
+       \note Water Temperature curve input variable - Condenser Entering or Leaving Water Temperature for curves
+  A11, \field Normalized Capacity Function of Temperature Curve Name
+       \required-field
+       \type object-list
+       \object-list BivariateFunctions
+       \note: CAPFT - Normalized Capacity Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+  A12, \field Fuel Energy Input Ratio Function of Temperature Curve Name
+       \required-field
+       \type object-list
+       \object-list BivariateFunctions
+       \note EIRFT - Fuel Energy Input Ratio Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+  A13, \field Fuel Energy Input Ratio Function of PLR Curve Name
+       \required-field
+       \type object-list
+       \object-list UnivariateFunctions
+       \note EIRFPLR - Fuel Energy Input Ratio Function of Part Load Ratio(PLR) Curve Name,
+       \note which is a cubic curve or a lookup table.
+  N7 , \field Minimum Part Load Ratio
+       \minimum> 0.0
+       \maximum 1.0
+       \default 0.1
+       \note Minimum Part Load Ratio (PLR) in between 0 and 1
+  N8 , \field Maximum Part Load Ratio
+       \minimum> 0.0
+       \maximum 1.0
+       \default 1.0
+       \note Maximum Part Load Ratio (PLR) in between 0 and 1
+  A14, \field Defrost Control Type
+       \type choice
+       \key Timed
+       \key OnDemand
+       \default Timed
+       \note Defrost operation control type: Timed or OnDemand
+  N9 , \field Defrost Operation Time Fraction
+       \minimum 0
+       \maximum 1
+       \default 0
+       \note Defrost operation time fraction, which will be used only for Timed Defrost Control Type.
+  A15, \field Fuel Energy Input Ratio Defrost Adjustment Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note EIRDEFROST - Energy Input Ratio Defrost Adjustment Curve Name,
+       \note which is a cubic curve or a lookup table function of Outdoor Air Temperature.
+       \note This field is only used when OnDemand Defrost Control Type is selected.
+  N10, \field Resistive Defrost Heater Capacity
+       \units W
+       \minimum 0
+       \default 0
+       \note The heating power of electric resistive defrost heater. Only used for timed defrost control type.
+  N11, \field Maximum Outdoor Dry-bulb Temperature for Defrost Operation
+       \units C
+       \minimum 0
+       \maximum 10
+       \default 5
+       \note There will be no defrost operation when outdoor air is above this temperature.
+  A16, \field Cycling Ratio Factor Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Cycling Ratio Factor (CRF) Curve Name,
+       \note which is a cubic curve or a lookup table function of Cycling Ratio (defined as = PLR/PLRmin);
+       \note if left blank, no adjustment will be made.
+  N12, \field Nominal Auxiliary Electric Power
+       \units W
+       \minimum 0
+       \note Nominal Auxiliary Electric Power in [W]
+  A17, \field Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name
+       \type object-list
+       \object-list BivariateFunctions
+       \note Auxiliary Electric EIRFT - Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+       \note which accounts for system internal fans, pumps, and electronics
+  A18, \field Auxiliary Electric Energy Input Ratio Function of PLR Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Auxiliary Electric EIRFPLR - Auxiliary Electric Energy Input Ratio Function of PLR (Part Load Ratio) Curve Name,
+       \note which is a cubic curve or a lookup table.
+  N13; \field Standby Electric Power
+       \units W
+       \minimum 0
+       \default 0
+       \note Standby Electric Power in [W]
+
+HeatPump:AirToWater:FuelFired:Cooling,
+       \memo The object defines a fuel-fired absorption heat pump based on equation-fit models.
+       \min-fields 26
+  A1 , \field Name
+       \required-field
+       \reference HeatPumpAirToWaterFuelFiredCoolingNames
+       \note Name of the fuel fired absorption heat pump system system
+       \reference-class-name validPlantEquipmentTypes
+       \reference validPlantEquipmentNames
+       \reference-class-name validBranchEquipmentTypes
+       \reference validBranchEquipmentNames
+  A2 , \field Water Inlet Node Name
+       \required-field
+       \type node
+       \note Inlet node name of the water side connection
+  A3 , \field Water Outlet Node Name
+       \required-field
+       \type node
+       \note Outlet node name of the water side connection
+  A4 , \field Air Source Node Name
+       \type object-list
+       \object-list OutdoorAirNodeNames
+       \note This is the air source node name, which is the condenser side of the heat pump in cooling mode.
+       \note Enter the name of an OutdoorAir:Node object.
+  A5 , \field Companion Heating Heat Pump Name
+       \note The name of the companion HeatPump:AirToWater:FuelFired:Heating object
+       \note This field is used for a heat pump with switchable heating and cooling mode.
+       \type object-list
+       \object-list HeatPumpAirToWaterFuelFiredHeatingNames
+  A6 , \field Fuel Type
+       \type choice
+       \key NaturalGas
+       \key Propane
+       \key FuelOilNo1
+       \key FuelOilNo2
+       \key Diesel
+       \key Gasoline
+       \key Coal
+       \key OtherFuel1
+       \key OtherFuel2
+       \default NaturalGas
+       \note Fuel Type (NaturalGas, Propane, Gasoline, Diesel etc.)
+  A7 , \field End-Use Subcategory
+       \type alpha
+       \retaincase
+       \default General
+       \note Any text may be used here to categorize the end-uses in the ABUPS End Uses by Subcategory table.
+  N1 , \field Nominal Cooling Capacity
+       \autosizable
+       \minimum> 0
+       \units W
+       \note Nominal Cooling Capacity in [W] (autosizeable)
+  N2 , \field Nominal COP
+       \type real
+       \minimum> 0
+       \default 1.0
+       \units W/W
+       \note Nominal COP (Coefficient of Performance)
+  N3 , \field Design Flow Rate
+       \autosizable
+       \minimum> 0
+       \units m3/s
+       \note Design Flow Rate in m3/s (autosizeable)
+  N4 , \field Design Supply Temperature
+       \default 7.0
+       \units C
+       \note Design Supply Temperature in [degree C]
+  N5 , \field Design Temperature Lift
+       \autosizable
+       \default 11.1
+       \units deltaC
+       \note Design Temperature Lift in [degree C]
+  N6 , \field Sizing Factor
+       \minimum 1.0
+       \default 1.0
+       \note Sizing Factor for equipment sizing
+  A8 , \field Flow Mode
+       \type choice
+       \key NotModulated
+       \key ConstantFlow
+       \key LeavingSetpointModulated
+       \default NotModulated
+       \note Flow Mode for the water side of the fuel-fired absorption heat pump
+  A9 , \field Outdoor Air Temperature Curve Input Variable
+       \type choice
+       \key DryBulb
+       \key WetBulb
+       \default DryBulb
+       \note Outdoor air temperature curve input variable;
+       \note The options are Outdoor Air Dry Bulb or Wet Bulb temperature for curves
+  A10, \field Water Temperature Curve Input Variable
+       \type choice
+       \key EnteringEvaporator
+       \key LeavingEvaporator
+       \default EnteringEvaporator
+       \note Water Temperature curve input variable - Condenser Entering or Leaving Water Temperature for curves
+  A11, \field Normalized Capacity Function of Temperature Curve Name
+       \required-field
+       \type object-list
+       \object-list BivariateFunctions
+       \note: CAPFT - Normalized Capacity Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+  A12, \field Fuel Energy Input Ratio Function of Temperature Curve Name
+       \required-field
+       \type object-list
+       \object-list BivariateFunctions
+       \note EIRFT - Fuel Energy Input Ratio Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+  A13, \field Fuel Energy Input Ratio Function of PLR Curve Name
+       \required-field
+       \type object-list
+       \object-list UnivariateFunctions
+       \note EIRFPLR - Fuel Energy Input Ratio Function of Part Load Ratio(PLR) Curve Name,
+       \note which is a cubic curve or a lookup table.
+  N7 , \field Minimum Part Load Ratio
+       \minimum> 0.0
+       \maximum 1.0
+       \default 0.1
+       \note Minimum Part Load Ratio (PLR) in between 0 and 1
+  N8 , \field Maximum Part Load Ratio
+       \minimum> 0.0
+       \maximum 1.0
+       \default 1.0
+       \note Maximum Part Load Ratio (PLR) in between 0 and 1
+  A14, \field Cycling Ratio Factor Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Cycling Ratio Factor (CRF) Curve Name,
+       \note which is a cubic curve or a lookup table function of Cycling Ratio (defined as = PLR/PLRmin);
+       \note if left blank, no adjustment will be made.
+  N9 , \field Nominal Auxiliary Electric Power
+       \units W
+       \minimum 0
+       \note Nominal Auxiliary Electric Power in [W]
+  A15, \field Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name
+       \type object-list
+       \object-list BivariateFunctions
+       \note Auxiliary Electric EIRFT - Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+       \note which accounts for system internal fans, pumps, and electronics
+  A16, \field Auxiliary Electric Energy Input Ratio Function of PLR Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Auxiliary Electric EIRFPLR - Auxiliary Electric Energy Input Ratio Function of PLR (Part Load Ratio) Curve Name,
+       \note which is a cubic curve or a lookup table.
+  N10; \field Standby Electric Power
+       \units W
+       \minimum 0
+       \default 0
+       \note Standby Electric Power in [W]
+
 HeatPump:WaterToWater:EquationFit:Heating,
         \memo simple water-water hp curve-fit model
         \min-fields 11
diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd
index 025f7314306..04e7e2495db 100644
--- a/resources/model/OpenStudio.idd
+++ b/resources/model/OpenStudio.idd
@@ -14188,6 +14188,347 @@ OS:HeatPump:PlantLoop:EIR:Cooling,
        \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)
 
+OS:HeatPump:AirToWater:FuelFired:Heating,
+       \memo The object defines a fuel-fired absorption heat pump based on equation-fit models.
+       \min-fields 32
+   A1, \field Handle
+       \type handle
+       \required-field
+   A2, \field Name
+       \required-field
+       \reference HeatPumpAirToWaterFuelFiredHeatingNames
+       \note Name of the fuel fired absorption heat pump system system
+       \reference ConnectionObject
+   A3, \field Water Inlet Node Name
+       \type object-list
+       \required-field
+       \object-list ConnectionNames
+       \note Inlet node name of the water side connection
+   A4, \field Water Outlet Node Name
+       \type object-list
+       \required-field
+       \object-list ConnectionNames
+       \note Outlet node name of the water side connection
+   A5, \field Air Source Node Name
+       \type object-list
+       \object-list OutdoorAirNodeNames
+       \note This is the air source node name, which is the evaporator side of the heat pump in heating mode.
+       \note Enter the name of an OutdoorAir:Node object.
+   A6, \field Companion Cooling Heat Pump Name
+       \note The name of the companion HeatPump:AirToWater:FuelFired:Cooling object
+       \note This field is used for a heat pump with switchable heating and cooling mode.
+       \type object-list
+       \object-list HeatPumpAirToWaterFuelFiredCoolingNames
+   A7, \field Fuel Type
+       \required-field
+       \type choice
+       \key NaturalGas
+       \key Propane
+       \key FuelOilNo1
+       \key FuelOilNo2
+       \key Diesel
+       \key Gasoline
+       \key Coal
+       \key OtherFuel1
+       \key OtherFuel2
+       \note Fuel Type (NaturalGas, Propane, Gasoline, Diesel etc.)
+   A8, \field End-Use Subcategory
+       \type alpha
+       \retaincase
+       \default General
+       \note Any text may be used here to categorize the end-uses in the ABUPS End Uses by Subcategory table.
+   N1, \field Nominal Heating Capacity
+       \autosizable
+       \minimum> 0
+       \units W
+       \required-field
+       \note Nominal Heating Capacity in [W] (autosizeable)
+   N2, \field Nominal COP
+       \required-field
+       \type real
+       \minimum> 0
+       \units W/W
+       \note Nominal COP (Coefficient of Performance)
+   N3, \field Design Flow Rate
+       \autosizable
+       \minimum> 0
+       \units m3/s
+       \required-field
+       \note Design Flow Rate in m3/s (autosizeable)
+   N4, \field Design Supply Temperature
+       \required-field
+       \units C
+       \note Design Supply Temperature in [degree C]
+   N5, \field Design Temperature Lift
+       \autosizable
+       \required-field
+       \units deltaC
+       \note Design Temperature Lift in [degree C]
+   N6, \field Sizing Factor
+       \minimum 1.0
+       \required-field
+       \note Sizing Factor for equipment sizing
+   A9, \field Flow Mode
+       \required-field
+       \type choice
+       \key NotModulated
+       \key ConstantFlow
+       \key LeavingSetpointModulated
+       \note Flow Mode for the water side of the fuel-fired absorption heat pump
+   A10,\field Outdoor Air Temperature Curve Input Variable
+       \required-field
+       \type choice
+       \key DryBulb
+       \key WetBulb
+       \note Outdoor air temperature curve input variable;
+       \note The options are Outdoor Air Dry Bulb or Wet Bulb temperature for curves
+   A11,\field Water Temperature Curve Input Variable
+       \required-field
+       \type choice
+       \key EnteringCondenser
+       \key LeavingCondenser
+       \note Water Temperature curve input variable - Condenser Entering or Leaving Water Temperature for curves
+   A12,\field Normalized Capacity Function of Temperature Curve Name
+       \required-field
+       \type object-list
+       \object-list BivariateFunctions
+       \note: CAPFT - Normalized Capacity Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+   A13,\field Fuel Energy Input Ratio Function of Temperature Curve Name
+       \required-field
+       \type object-list
+       \object-list BivariateFunctions
+       \note EIRFT - Fuel Energy Input Ratio Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+   A14,\field Fuel Energy Input Ratio Function of PLR Curve Name
+       \required-field
+       \type object-list
+       \object-list UnivariateFunctions
+       \note EIRFPLR - Fuel Energy Input Ratio Function of Part Load Ratio(PLR) Curve Name,
+       \note which is a cubic curve or a lookup table.
+   N7, \field Minimum Part Load Ratio
+       \minimum> 0.0
+       \maximum 1.0
+       \required-field
+       \note Minimum Part Load Ratio (PLR) in between 0 and 1
+   N8, \field Maximum Part Load Ratio
+       \minimum> 0.0
+       \maximum 1.0
+       \required-field
+       \note Maximum Part Load Ratio (PLR) in between 0 and 1
+   A15,\field Defrost Control Type
+       \type choice
+       \key Timed
+       \key OnDemand
+       \required-field
+       \note Defrost operation control type: Timed or OnDemand
+   N9, \field Defrost Operation Time Fraction
+       \minimum 0
+       \maximum 1
+       \required-field
+       \note Defrost operation time fraction, which will be used only for Timed Defrost Control Type.
+   A16,\field Fuel Energy Input Ratio Defrost Adjustment Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note EIRDEFROST - Energy Input Ratio Defrost Adjustment Curve Name,
+       \note which is a cubic curve or a lookup table function of Outdoor Air Temperature.
+       \note This field is only used when OnDemand Defrost Control Type is selected.
+   N10,\field Resistive Defrost Heater Capacity
+       \units W
+       \minimum 0
+       \required-field
+       \note The heating power of electric resistive defrost heater. Only used for timed defrost control type.
+   N11,\field Maximum Outdoor Dry-bulb Temperature for Defrost Operation
+       \units C
+       \minimum 0
+       \maximum 10
+       \required-field
+       \note There will be no defrost operation when outdoor air is above this temperature.
+   A17,\field Cycling Ratio Factor Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Cycling Ratio Factor (CRF) Curve Name,
+       \note which is a cubic curve or a lookup table function of Cycling Ratio (defined as = PLR/PLRmin);
+       \note if left blank, no adjustment will be made.
+   N12,\field Nominal Auxiliary Electric Power
+       \units W
+       \minimum 0
+       \required-field
+       \note Nominal Auxiliary Electric Power in [W]
+   A18,\field Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name
+       \type object-list
+       \object-list BivariateFunctions
+       \note Auxiliary Electric EIRFT - Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+       \note which accounts for system internal fans, pumps, and electronics
+   A19,\field Auxiliary Electric Energy Input Ratio Function of PLR Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Auxiliary Electric EIRFPLR - Auxiliary Electric Energy Input Ratio Function of PLR (Part Load Ratio) Curve Name,
+       \note which is a cubic curve or a lookup table.
+   N13;\field Standby Electric Power
+       \units W
+       \minimum 0
+       \required-field
+       \note Standby Electric Power in [W]
+
+OS:HeatPump:AirToWater:FuelFired:Cooling,
+       \memo The object defines a fuel-fired absorption heat pump based on equation-fit models.
+       \min-fields 27
+   A1, \field Handle
+       \type handle
+       \required-field
+   A2, \field Name
+       \required-field
+       \reference HeatPumpAirToWaterFuelFiredCoolingNames
+       \note Name of the fuel fired absorption heat pump system system
+       \reference ConnectionObject
+   A3, \field Water Inlet Node Name
+       \type object-list
+       \required-field
+       \object-list ConnectionNames
+       \note Inlet node name of the water side connection
+   A4, \field Water Outlet Node Name
+       \type object-list
+       \required-field
+       \object-list ConnectionNames
+       \note Outlet node name of the water side connection
+   A5, \field Air Source Node Name
+       \type object-list
+       \object-list OutdoorAirNodeNames
+       \note This is the air source node name, which is the condenser side of the heat pump in cooling mode.
+       \note Enter the name of an OutdoorAir:Node object.
+   A6, \field Companion Heating Heat Pump Name
+       \note The name of the companion HeatPump:AirToWater:FuelFired:Heating object
+       \note This field is used for a heat pump with switchable heating and cooling mode.
+       \type object-list
+       \object-list HeatPumpAirToWaterFuelFiredHeatingNames
+   A7, \field Fuel Type
+       \required-field
+       \type choice
+       \key NaturalGas
+       \key Propane
+       \key FuelOilNo1
+       \key FuelOilNo2
+       \key Diesel
+       \key Gasoline
+       \key Coal
+       \key OtherFuel1
+       \key OtherFuel2
+       \required-field
+       \note Fuel Type (NaturalGas, Propane, Gasoline, Diesel etc.)
+   A8, \field End-Use Subcategory
+       \type alpha
+       \retaincase
+       \default General
+       \note Any text may be used here to categorize the end-uses in the ABUPS End Uses by Subcategory table.
+   N1, \field Nominal Cooling Capacity
+       \autosizable
+       \minimum> 0
+       \units W
+       \required-field
+       \note Nominal Cooling Capacity in [W] (autosizeable)
+   N2, \field Nominal COP
+       \required-field
+       \type real
+       \minimum> 0
+       \units W/W
+       \note Nominal COP (Coefficient of Performance)
+   N3, \field Design Flow Rate
+       \autosizable
+       \minimum> 0
+       \units m3/s
+       \required-field
+       \note Design Flow Rate in m3/s (autosizeable)
+   N4, \field Design Supply Temperature
+       \required-field
+       \units C
+       \note Design Supply Temperature in [degree C]
+   N5, \field Design Temperature Lift
+       \autosizable
+       \required-field
+       \units deltaC
+       \note Design Temperature Lift in [degree C]
+   N6, \field Sizing Factor
+       \minimum 1.0
+       \required-field
+       \note Sizing Factor for equipment sizing
+   A9, \field Flow Mode
+       \required-field
+       \type choice
+       \key NotModulated
+       \key ConstantFlow
+       \key LeavingSetpointModulated
+       \note Flow Mode for the water side of the fuel-fired absorption heat pump
+   A10,\field Outdoor Air Temperature Curve Input Variable
+       \required-field
+       \type choice
+       \key DryBulb
+       \key WetBulb
+       \note Outdoor air temperature curve input variable;
+       \note The options are Outdoor Air Dry Bulb or Wet Bulb temperature for curves
+   A11,\field Water Temperature Curve Input Variable
+       \required-field
+       \type choice
+       \key EnteringEvaporator
+       \key LeavingEvaporator
+       \note Water Temperature curve input variable - Condenser Entering or Leaving Water Temperature for curves
+   A12,\field Normalized Capacity Function of Temperature Curve Name
+       \required-field
+       \type object-list
+       \object-list BivariateFunctions
+       \note: CAPFT - Normalized Capacity Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+   A13,\field Fuel Energy Input Ratio Function of Temperature Curve Name
+       \required-field
+       \type object-list
+       \object-list BivariateFunctions
+       \note EIRFT - Fuel Energy Input Ratio Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+   A14,\field Fuel Energy Input Ratio Function of PLR Curve Name
+       \required-field
+       \type object-list
+       \object-list UnivariateFunctions
+       \note EIRFPLR - Fuel Energy Input Ratio Function of Part Load Ratio(PLR) Curve Name,
+       \note which is a cubic curve or a lookup table.
+   N7, \field Minimum Part Load Ratio
+       \minimum> 0.0
+       \maximum 1.0
+       \required-field
+       \note Minimum Part Load Ratio (PLR) in between 0 and 1
+   N8, \field Maximum Part Load Ratio
+       \minimum> 0.0
+       \maximum 1.0
+       \required-field
+       \note Maximum Part Load Ratio (PLR) in between 0 and 1
+   A15,\field Cycling Ratio Factor Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Cycling Ratio Factor (CRF) Curve Name,
+       \note which is a cubic curve or a lookup table function of Cycling Ratio (defined as = PLR/PLRmin);
+       \note if left blank, no adjustment will be made.
+   N9, \field Nominal Auxiliary Electric Power
+       \units W
+       \minimum 0
+       \required-field
+       \note Nominal Auxiliary Electric Power in [W]
+   A16,\field Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name
+       \type object-list
+       \object-list BivariateFunctions
+       \note Auxiliary Electric EIRFT - Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name,
+       \note which is a biquadratic curve or a lookup table.
+       \note which accounts for system internal fans, pumps, and electronics
+   A17,\field Auxiliary Electric Energy Input Ratio Function of PLR Curve Name
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Auxiliary Electric EIRFPLR - Auxiliary Electric Energy Input Ratio Function of PLR (Part Load Ratio) Curve Name,
+       \note which is a cubic curve or a lookup table.
+   N10;\field Standby Electric Power
+       \units W
+       \minimum 0
+       \required-field
+       \note Standby Electric Power in [W]
+
 OS:Chiller:Electric:EIR,
        \memo This chiller model is the empirical model from the DOE-2 building Energy
        \memo simulation program. Chiller performance at off-reference conditions is modeled
diff --git a/src/energyplus/CMakeLists.txt b/src/energyplus/CMakeLists.txt
index b8d29c9202d..1da5afc5462 100644
--- a/src/energyplus/CMakeLists.txt
+++ b/src/energyplus/CMakeLists.txt
@@ -225,6 +225,8 @@ set(${target_name}_src
   ForwardTranslator/ForwardTranslateHeatExchangerDesiccantBalancedFlow.cpp
   ForwardTranslator/ForwardTranslateHeatExchangerDesiccantBalancedFlowPerformanceDataType1.cpp
   ForwardTranslator/ForwardTranslateHeatExchangerFluidToFluid.cpp
+  ForwardTranslator/ForwardTranslateHeatPumpAirToWaterFuelFiredHeating.cpp
+  ForwardTranslator/ForwardTranslateHeatPumpAirToWaterFuelFiredCooling.cpp
   ForwardTranslator/ForwardTranslateHeatPumpWaterToWaterEquationFitCooling.cpp
   ForwardTranslator/ForwardTranslateHeatPumpWaterToWaterEquationFitHeating.cpp
   ForwardTranslator/ForwardTranslateHeatPumpPlantLoopEIRCooling.cpp
@@ -735,6 +737,7 @@ set(${target_name}_test_src
   Test/GroundHeatExchangerHorizontalTrench_GTest.cpp
   Test/HeatExchangerDesiccantBalancedFlow_GTest.cpp
   Test/HeatExchangerDesiccantBalancedFlowPerformanceDataType1_GTest.cpp
+  Test/HeatPumpAirToWaterFuelFired_GTest.cpp
   Test/HeatPumpWaterToWaterEquationFit_GTest.cpp
   Test/HeatPumpPlantLoopEIR_GTest.cpp
   Test/HotWaterEquipment_GTest.cpp
diff --git a/src/energyplus/ForwardTranslator.cpp b/src/energyplus/ForwardTranslator.cpp
index c5794b723a1..d04da5a89ab 100644
--- a/src/energyplus/ForwardTranslator.cpp
+++ b/src/energyplus/ForwardTranslator.cpp
@@ -1959,6 +1959,18 @@ namespace energyplus {
         retVal = translateHeatExchangerFluidToFluid(mo);
         break;
       }
+
+      case openstudio::IddObjectType::OS_HeatPump_AirToWater_FuelFired_Heating: {
+        auto mo = modelObject.cast<HeatPumpAirToWaterFuelFiredHeating>();
+        retVal = translateHeatPumpAirToWaterFuelFiredHeating(mo);
+        break;
+      }
+      case openstudio::IddObjectType::OS_HeatPump_AirToWater_FuelFired_Cooling: {
+        auto mo = modelObject.cast<HeatPumpAirToWaterFuelFiredCooling>();
+        retVal = translateHeatPumpAirToWaterFuelFiredCooling(mo);
+        break;
+      }
+
       case openstudio::IddObjectType::OS_HeatPump_WaterToWater_EquationFit_Cooling: {
         auto mo = modelObject.cast<HeatPumpWaterToWaterEquationFitCooling>();
         retVal = translateHeatPumpWaterToWaterEquationFitCooling(mo);
diff --git a/src/energyplus/ForwardTranslator.hpp b/src/energyplus/ForwardTranslator.hpp
index a914f18900e..65c4768fd0b 100644
--- a/src/energyplus/ForwardTranslator.hpp
+++ b/src/energyplus/ForwardTranslator.hpp
@@ -285,6 +285,8 @@ namespace model {
   class HeatExchangerDesiccantBalancedFlow;
   class HeatExchangerDesiccantBalancedFlowPerformanceDataType1;
   class HeatExchangerFluidToFluid;
+  class HeatPumpAirToWaterFuelFiredHeating;
+  class HeatPumpAirToWaterFuelFiredCooling;
   class HeatPumpWaterToWaterEquationFitCooling;
   class HeatPumpWaterToWaterEquationFitHeating;
   class HeatPumpPlantLoopEIRCooling;
@@ -1114,6 +1116,10 @@ namespace energyplus {
 
     boost::optional<IdfObject> translateHeatExchangerFluidToFluid(model::HeatExchangerFluidToFluid& modelObject);
 
+    boost::optional<IdfObject> translateHeatPumpAirToWaterFuelFiredHeating(model::HeatPumpAirToWaterFuelFiredHeating& modelObject);
+
+    boost::optional<IdfObject> translateHeatPumpAirToWaterFuelFiredCooling(model::HeatPumpAirToWaterFuelFiredCooling& modelObject);
+
     boost::optional<IdfObject> translateHeatPumpWaterToWaterEquationFitCooling(model::HeatPumpWaterToWaterEquationFitCooling& modelObject);
 
     boost::optional<IdfObject> translateHeatPumpWaterToWaterEquationFitHeating(model::HeatPumpWaterToWaterEquationFitHeating& modelObject);
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpAirToWaterFuelFiredCooling.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpAirToWaterFuelFiredCooling.cpp
new file mode 100644
index 00000000000..22981ffb8ef
--- /dev/null
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpAirToWaterFuelFiredCooling.cpp
@@ -0,0 +1,195 @@
+/***********************************************************************************************************************
+*  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 "../ForwardTranslator.hpp"
+#include "../../model/Model.hpp"
+
+#include "../../model/HeatPumpAirToWaterFuelFiredCooling.hpp"
+#include "../../model/Node.hpp"
+#include "../../model/Node_Impl.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredHeating_Impl.hpp"
+#include "../../model/CurveBiquadratic.hpp"
+#include "../../model/CurveQuadratic.hpp"
+
+#include <utilities/idd/HeatPump_AirToWater_FuelFired_Cooling_FieldEnums.hxx>
+#include <utilities/idd/IddEnums.hxx>
+
+using namespace openstudio::model;
+
+namespace openstudio {
+
+namespace energyplus {
+
+  boost::optional<IdfObject> ForwardTranslator::translateHeatPumpAirToWaterFuelFiredCooling(model::HeatPumpAirToWaterFuelFiredCooling& modelObject) {
+
+    // Instantiate an IdfObject of the class to store the values
+    IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::HeatPump_AirToWater_FuelFired_Cooling, modelObject);
+
+    // Water Inlet Node Name: Required Node
+    if (auto node_ = modelObject.inletModelObject()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::WaterInletNodeName, node_->nameString());
+    }
+
+    // Water Outlet Node Name: Required Node
+    if (auto node_ = modelObject.outletModelObject()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::WaterOutletNodeName, node_->nameString());
+    }
+
+    // Air Source Node Name
+    const std::string oaNodeName = modelObject.nameString() + " OA Node";
+    idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::AirSourceNodeName, oaNodeName);
+
+    IdfObject _oaNode(openstudio::IddObjectType::OutdoorAir_Node);
+    _oaNode.setString(0, oaNodeName);
+    m_idfObjects.push_back(_oaNode);
+
+    // Companion Cooling Heat Pump Name: Optional Object
+    if (boost::optional<HeatPumpAirToWaterFuelFiredHeating> companionHeatingHeatPump_ = modelObject.companionHeatingHeatPump()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(companionHeatingHeatPump_.get())) {
+        idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::CompanionHeatingHeatPumpName, wo_->nameString());
+      }
+    }
+
+    // Fuel Type: Optional String
+    const std::string fuelType = modelObject.fuelType();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::FuelType, fuelType);
+
+    // End-Use Subcategory: Optional String
+    const std::string endUseSubcategory = modelObject.endUseSubcategory();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::EndUseSubcategory, endUseSubcategory);
+
+    // Nominal Cooling Capacity
+    if (modelObject.isNominalCoolingCapacityAutosized()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::NominalCoolingCapacity, "Autosize");
+    } else {
+      idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::NominalCoolingCapacity, modelObject.nominalCoolingCapacity().get());
+    }
+
+    // Nominal COP: Optional Double
+    const double nominalCOP = modelObject.nominalCOP();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::NominalCOP, nominalCOP);
+
+    // Design Flow Rate
+    if (modelObject.isDesignFlowRateAutosized()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::DesignFlowRate, "Autosize");
+    } else {
+      idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::DesignFlowRate, modelObject.designFlowRate().get());
+    }
+
+    // Design Supply Temperature: Optional Double
+    const double designSupplyTemperature = modelObject.designSupplyTemperature();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::DesignSupplyTemperature, designSupplyTemperature);
+
+    if (modelObject.isDesignTemperatureLiftAutosized()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::DesignTemperatureLift, "Autosize");
+    } else {
+      idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::DesignTemperatureLift, modelObject.designTemperatureLift().get());
+    }
+
+    // Sizing Factor: Optional Double
+    const double sizingFactor = modelObject.sizingFactor();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::SizingFactor, sizingFactor);
+
+    // Flow Mode: Optional String
+    const std::string flowMode = modelObject.flowMode();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::FlowMode, flowMode);
+
+    // Outdoor Air Temperature Curve Input Variable: Optional String
+    const std::string outdoorAirTemperatureCurveInputVariable = modelObject.outdoorAirTemperatureCurveInputVariable();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::OutdoorAirTemperatureCurveInputVariable,
+                        outdoorAirTemperatureCurveInputVariable);
+
+    // Water Temperature Curve Input Variable: Optional String
+    const std::string waterTemperatureCurveInputVariable = modelObject.waterTemperatureCurveInputVariable();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::WaterTemperatureCurveInputVariable, waterTemperatureCurveInputVariable);
+
+    // Normalized Capacity Function of Temperature Curve Name: Required Object
+    Curve normalizedCapacityFunctionofTemperatureCurve = modelObject.normalizedCapacityFunctionofTemperatureCurve();
+    if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(normalizedCapacityFunctionofTemperatureCurve)) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::NormalizedCapacityFunctionofTemperatureCurveName, wo_->nameString());
+    }
+
+    // Fuel Energy Input Ratio Function of Temperature Curve Name: Required Object
+    Curve fuelEnergyInputRatioFunctionofTemperatureCurve = modelObject.fuelEnergyInputRatioFunctionofTemperatureCurve();
+    if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(fuelEnergyInputRatioFunctionofTemperatureCurve)) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::FuelEnergyInputRatioFunctionofTemperatureCurveName, wo_->nameString());
+    }
+
+    // Fuel Energy Input Ratio Function of PLR Curve Name: Required Object
+    Curve fuelEnergyInputRatioFunctionofPLRCurve = modelObject.fuelEnergyInputRatioFunctionofPLRCurve();
+    if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(fuelEnergyInputRatioFunctionofPLRCurve)) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::FuelEnergyInputRatioFunctionofPLRCurveName, wo_->nameString());
+    }
+
+    // Minimum Part Load Ratio: Optional Double
+    const double minimumPartLoadRatio = modelObject.minimumPartLoadRatio();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::MinimumPartLoadRatio, minimumPartLoadRatio);
+
+    // Maximum Part Load Ratio: Optional Double
+    const double maximumPartLoadRatio = modelObject.maximumPartLoadRatio();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::MaximumPartLoadRatio, maximumPartLoadRatio);
+
+    // Cycling Ratio Factor Curve Name: Optional Object
+    if (boost::optional<Curve> cyclingRatioFactorCurve_ = modelObject.cyclingRatioFactorCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(cyclingRatioFactorCurve_.get())) {
+        idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::CyclingRatioFactorCurveName, wo_->nameString());
+      }
+    }
+
+    // Nominal Auxiliary Electric Power: Optional Double
+    const double nominalAuxiliaryElectricPower = modelObject.nominalAuxiliaryElectricPower();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::NominalAuxiliaryElectricPower, nominalAuxiliaryElectricPower);
+
+    // Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve_ =
+          modelObject.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Auxiliary Electric Energy Input Ratio Function of PLR Curve Name: Optional Object
+    if (boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofPLRCurve_ =
+          modelObject.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(auxiliaryElectricEnergyInputRatioFunctionofPLRCurve_.get())) {
+        idfObject.setString(HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName, wo_->nameString());
+      }
+    }
+
+    // Standby Electric Power: Optional Double
+    const double standbyElectricPower = modelObject.standbyElectricPower();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_CoolingFields::StandbyElectricPower, standbyElectricPower);
+
+    return idfObject;
+  }  // End of translate function
+
+}  // end namespace energyplus
+}  // end namespace openstudio
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpAirToWaterFuelFiredHeating.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpAirToWaterFuelFiredHeating.cpp
new file mode 100644
index 00000000000..21fa731c952
--- /dev/null
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateHeatPumpAirToWaterFuelFiredHeating.cpp
@@ -0,0 +1,219 @@
+/***********************************************************************************************************************
+*  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 "../ForwardTranslator.hpp"
+#include "../../model/Model.hpp"
+
+#include "../../model/HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "../../model/Node.hpp"
+#include "../../model/Node_Impl.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredCooling.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredCooling_Impl.hpp"
+#include "../../model/CurveBiquadratic.hpp"
+#include "../../model/CurveQuadratic.hpp"
+
+#include <utilities/idd/HeatPump_AirToWater_FuelFired_Heating_FieldEnums.hxx>
+#include <utilities/idd/IddEnums.hxx>
+
+using namespace openstudio::model;
+
+namespace openstudio {
+
+namespace energyplus {
+
+  boost::optional<IdfObject> ForwardTranslator::translateHeatPumpAirToWaterFuelFiredHeating(model::HeatPumpAirToWaterFuelFiredHeating& modelObject) {
+
+    // Instantiate an IdfObject of the class to store the values
+    IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::HeatPump_AirToWater_FuelFired_Heating, modelObject);
+
+    // Water Inlet Node Name: Required Node
+    if (auto node_ = modelObject.inletModelObject()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::WaterInletNodeName, node_->nameString());
+    }
+
+    // Water Outlet Node Name: Required Node
+    if (auto node_ = modelObject.outletModelObject()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::WaterOutletNodeName, node_->nameString());
+    }
+
+    // Air Source Node Name
+    const std::string oaNodeName = modelObject.nameString() + " OA Node";
+    idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::AirSourceNodeName, oaNodeName);
+
+    IdfObject _oaNode(openstudio::IddObjectType::OutdoorAir_Node);
+    _oaNode.setString(0, oaNodeName);
+    m_idfObjects.push_back(_oaNode);
+
+    // Companion Cooling Heat Pump Name: Optional Object
+    if (boost::optional<HeatPumpAirToWaterFuelFiredCooling> companionCoolingHeatPump_ = modelObject.companionCoolingHeatPump()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(companionCoolingHeatPump_.get())) {
+        idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::CompanionCoolingHeatPumpName, wo_->nameString());
+      }
+    }
+
+    // Fuel Type: Optional String
+    const std::string fuelType = modelObject.fuelType();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::FuelType, fuelType);
+
+    // End-Use Subcategory: Optional String
+    const std::string endUseSubcategory = modelObject.endUseSubcategory();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::EndUseSubcategory, endUseSubcategory);
+
+    // Nominal Heating Capacity
+    if (modelObject.isNominalHeatingCapacityAutosized()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::NominalHeatingCapacity, "Autosize");
+    } else {
+      idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::NominalHeatingCapacity, modelObject.nominalHeatingCapacity().get());
+    }
+
+    // Nominal COP: Optional Double
+    const double nominalCOP = modelObject.nominalCOP();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::NominalCOP, nominalCOP);
+
+    // Design Flow Rate
+    if (modelObject.isDesignFlowRateAutosized()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::DesignFlowRate, "Autosize");
+    } else {
+      idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::DesignFlowRate, modelObject.designFlowRate().get());
+    }
+
+    // Design Supply Temperature: Optional Double
+    const double designSupplyTemperature = modelObject.designSupplyTemperature();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::DesignSupplyTemperature, designSupplyTemperature);
+
+    if (modelObject.isDesignTemperatureLiftAutosized()) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::DesignTemperatureLift, "Autosize");
+    } else {
+      idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::DesignTemperatureLift, modelObject.designTemperatureLift().get());
+    }
+
+    // Sizing Factor: Optional Double
+    const double sizingFactor = modelObject.sizingFactor();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::SizingFactor, sizingFactor);
+
+    // Flow Mode: Optional String
+    const std::string flowMode = modelObject.flowMode();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::FlowMode, flowMode);
+
+    // Outdoor Air Temperature Curve Input Variable: Optional String
+    const std::string outdoorAirTemperatureCurveInputVariable = modelObject.outdoorAirTemperatureCurveInputVariable();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::OutdoorAirTemperatureCurveInputVariable,
+                        outdoorAirTemperatureCurveInputVariable);
+
+    // Water Temperature Curve Input Variable: Optional String
+    const std::string waterTemperatureCurveInputVariable = modelObject.waterTemperatureCurveInputVariable();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::WaterTemperatureCurveInputVariable, waterTemperatureCurveInputVariable);
+
+    // Normalized Capacity Function of Temperature Curve Name: Required Object
+    Curve normalizedCapacityFunctionofTemperatureCurve = modelObject.normalizedCapacityFunctionofTemperatureCurve();
+    if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(normalizedCapacityFunctionofTemperatureCurve)) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::NormalizedCapacityFunctionofTemperatureCurveName, wo_->nameString());
+    }
+
+    // Fuel Energy Input Ratio Function of Temperature Curve Name: Required Object
+    Curve fuelEnergyInputRatioFunctionofTemperatureCurve = modelObject.fuelEnergyInputRatioFunctionofTemperatureCurve();
+    if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(fuelEnergyInputRatioFunctionofTemperatureCurve)) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioFunctionofTemperatureCurveName, wo_->nameString());
+    }
+
+    // Fuel Energy Input Ratio Function of PLR Curve Name: Required Object
+    Curve fuelEnergyInputRatioFunctionofPLRCurve = modelObject.fuelEnergyInputRatioFunctionofPLRCurve();
+    if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(fuelEnergyInputRatioFunctionofPLRCurve)) {
+      idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioFunctionofPLRCurveName, wo_->nameString());
+    }
+
+    // Minimum Part Load Ratio: Optional Double
+    const double minimumPartLoadRatio = modelObject.minimumPartLoadRatio();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::MinimumPartLoadRatio, minimumPartLoadRatio);
+
+    // Maximum Part Load Ratio: Optional Double
+    const double maximumPartLoadRatio = modelObject.maximumPartLoadRatio();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::MaximumPartLoadRatio, maximumPartLoadRatio);
+
+    // Defrost Control Type: Optional String
+    const std::string defrostControlType = modelObject.defrostControlType();
+    idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::DefrostControlType, defrostControlType);
+
+    // Defrost Operation Time Fraction: Optional Double
+    const double defrostOperationTimeFraction = modelObject.defrostOperationTimeFraction();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::DefrostOperationTimeFraction, defrostOperationTimeFraction);
+
+    // Fuel Energy Input Ratio Defrost Adjustment Curve Name: Optional Object
+    if (boost::optional<Curve> fuelEnergyInputRatioDefrostAdjustmentCurve_ = modelObject.fuelEnergyInputRatioDefrostAdjustmentCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(fuelEnergyInputRatioDefrostAdjustmentCurve_.get())) {
+        idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioDefrostAdjustmentCurveName, wo_->nameString());
+      }
+    }
+
+    // Resistive Defrost Heater Capacity: Optional Double
+    const double resistiveDefrostHeaterCapacity = modelObject.resistiveDefrostHeaterCapacity();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::ResistiveDefrostHeaterCapacity, resistiveDefrostHeaterCapacity);
+
+    // Maximum Outdoor Dry-bulb Temperature for Defrost Operation: Optional Double
+    const double maximumOutdoorDrybulbTemperatureforDefrostOperation = modelObject.maximumOutdoorDrybulbTemperatureforDefrostOperation();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::MaximumOutdoorDrybulbTemperatureforDefrostOperation,
+                        maximumOutdoorDrybulbTemperatureforDefrostOperation);
+
+    // Cycling Ratio Factor Curve Name: Optional Object
+    if (boost::optional<Curve> cyclingRatioFactorCurve_ = modelObject.cyclingRatioFactorCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(cyclingRatioFactorCurve_.get())) {
+        idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::CyclingRatioFactorCurveName, wo_->nameString());
+      }
+    }
+
+    // Nominal Auxiliary Electric Power: Optional Double
+    const double nominalAuxiliaryElectricPower = modelObject.nominalAuxiliaryElectricPower();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::NominalAuxiliaryElectricPower, nominalAuxiliaryElectricPower);
+
+    // Auxiliary Electric Energy Input Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve_ =
+          modelObject.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Auxiliary Electric Energy Input Ratio Function of PLR Curve Name: Optional Object
+    if (boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofPLRCurve_ =
+          modelObject.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(auxiliaryElectricEnergyInputRatioFunctionofPLRCurve_.get())) {
+        idfObject.setString(HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName, wo_->nameString());
+      }
+    }
+
+    // Standby Electric Power: Optional Double
+    const double standbyElectricPower = modelObject.standbyElectricPower();
+    idfObject.setDouble(HeatPump_AirToWater_FuelFired_HeatingFields::StandbyElectricPower, standbyElectricPower);
+
+    return idfObject;
+  }  // End of translate function
+
+}  // end namespace energyplus
+}  // end namespace openstudio
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslatePlantEquipmentOperationSchemes.cpp b/src/energyplus/ForwardTranslator/ForwardTranslatePlantEquipmentOperationSchemes.cpp
index 70ae9aeceb5..daa53d3c698 100644
--- a/src/energyplus/ForwardTranslator/ForwardTranslatePlantEquipmentOperationSchemes.cpp
+++ b/src/energyplus/ForwardTranslator/ForwardTranslatePlantEquipmentOperationSchemes.cpp
@@ -103,6 +103,10 @@
 #include "../../model/PlantComponentTemperatureSource_Impl.hpp"
 #include "../../model/PlantComponentUserDefined.hpp"
 #include "../../model/PlantComponentUserDefined_Impl.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredHeating_Impl.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredCooling.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredCooling_Impl.hpp"
 #include "../../model/HeatPumpWaterToWaterEquationFitHeating.hpp"
 #include "../../model/HeatPumpWaterToWaterEquationFitHeating_Impl.hpp"
 #include "../../model/HeatPumpWaterToWaterEquationFitCooling.hpp"
@@ -343,6 +347,16 @@ namespace energyplus {
         result = mo.loadSideReferenceFlowRate();
         break;
       }
+      case openstudio::IddObjectType::OS_HeatPump_AirToWater_FuelFired_Heating: {
+        auto mo = component.cast<HeatPumpAirToWaterFuelFiredHeating>();
+        result = mo.designFlowRate();
+        break;
+      }
+      case openstudio::IddObjectType::OS_HeatPump_AirToWater_FuelFired_Cooling: {
+        auto mo = component.cast<HeatPumpAirToWaterFuelFiredCooling>();
+        result = mo.designFlowRate();
+        break;
+      }
       default: {
         break;
       }
@@ -609,6 +623,12 @@ namespace energyplus {
       case openstudio::IddObjectType::OS_HeatPump_PlantLoop_EIR_Cooling: {
         return ComponentType::COOLING;
       }
+      case openstudio::IddObjectType::OS_HeatPump_AirToWater_FuelFired_Heating: {
+        return ComponentType::HEATING;
+      }
+      case openstudio::IddObjectType::OS_HeatPump_AirToWater_FuelFired_Cooling: {
+        return ComponentType::COOLING;
+      }
       case openstudio::IddObjectType::OS_Generator_MicroTurbine_HeatRecovery: {
         // Maybe that should be both, in the case of an absorption chiller?
         // Also, should maybe check if it's in mode FollowThermal or FollowThermalLimitElectrical?
diff --git a/src/energyplus/Test/HeatPumpAirToWaterFuelFired_GTest.cpp b/src/energyplus/Test/HeatPumpAirToWaterFuelFired_GTest.cpp
new file mode 100644
index 00000000000..c84be388aa6
--- /dev/null
+++ b/src/energyplus/Test/HeatPumpAirToWaterFuelFired_GTest.cpp
@@ -0,0 +1,229 @@
+/***********************************************************************************************************************
+*  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/HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredCooling.hpp"
+#include "../../model/Node.hpp"
+#include "../../model/PlantLoop.hpp"
+#include "../../model/CurveBiquadratic.hpp"
+#include "../../model/CurveQuadratic.hpp"
+
+#include <utilities/idd/HeatPump_AirToWater_FuelFired_Heating_FieldEnums.hxx>
+#include <utilities/idd/HeatPump_AirToWater_FuelFired_Cooling_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_HeatPumpAirToWaterFuelFired) {
+  Model m;
+
+  PlantLoop plant_loop_ffhp_htg(m);
+  PlantLoop plant_loop_ffhp_clg(m);
+
+  HeatPumpAirToWaterFuelFiredHeating ffhp_htg(m);
+
+  EXPECT_TRUE(ffhp_htg.setFuelType("Propane"));
+  EXPECT_TRUE(ffhp_htg.setEndUseSubcategory("AnyText"));
+  EXPECT_TRUE(ffhp_htg.setNominalHeatingCapacity(1.0));
+  EXPECT_TRUE(ffhp_htg.setNominalCOP(2.0));
+  EXPECT_TRUE(ffhp_htg.setDesignFlowRate(3.0));
+  EXPECT_TRUE(ffhp_htg.setDesignSupplyTemperature(4.0));
+  EXPECT_TRUE(ffhp_htg.setDesignTemperatureLift(5.0));
+  EXPECT_TRUE(ffhp_htg.setSizingFactor(6.0));
+  EXPECT_TRUE(ffhp_htg.setFlowMode("ConstantFlow"));
+  EXPECT_TRUE(ffhp_htg.setOutdoorAirTemperatureCurveInputVariable("WetBulb"));
+  EXPECT_TRUE(ffhp_htg.setWaterTemperatureCurveInputVariable("LeavingCondenser"));
+  CurveBiquadratic curve1(m);
+  EXPECT_TRUE(ffhp_htg.setNormalizedCapacityFunctionofTemperatureCurve(curve1));
+  CurveBiquadratic curve2(m);
+  EXPECT_TRUE(ffhp_htg.setFuelEnergyInputRatioFunctionofTemperatureCurve(curve2));
+  CurveQuadratic curve3(m);
+  EXPECT_TRUE(ffhp_htg.setFuelEnergyInputRatioFunctionofPLRCurve(curve3));
+  EXPECT_TRUE(ffhp_htg.setMinimumPartLoadRatio(0.5));
+  EXPECT_TRUE(ffhp_htg.setMaximumPartLoadRatio(0.75));
+  EXPECT_TRUE(ffhp_htg.setDefrostControlType("OnDemand"));
+  EXPECT_TRUE(ffhp_htg.setDefrostOperationTimeFraction(0.8));
+  CurveQuadratic curve4(m);
+  EXPECT_TRUE(ffhp_htg.setFuelEnergyInputRatioDefrostAdjustmentCurve(curve4));
+  EXPECT_TRUE(ffhp_htg.setResistiveDefrostHeaterCapacity(10.0));
+  EXPECT_TRUE(ffhp_htg.setMaximumOutdoorDrybulbTemperatureforDefrostOperation(9.9));
+  CurveQuadratic curve5(m);
+  EXPECT_TRUE(ffhp_htg.setCyclingRatioFactorCurve(curve5));
+  EXPECT_TRUE(ffhp_htg.setNominalAuxiliaryElectricPower(12.0));
+  CurveBiquadratic curve6(m);
+  EXPECT_TRUE(ffhp_htg.setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(curve6));
+  CurveQuadratic curve7(m);
+  EXPECT_TRUE(ffhp_htg.setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(curve7));
+  EXPECT_TRUE(ffhp_htg.setStandbyElectricPower(13.0));
+
+  HeatPumpAirToWaterFuelFiredCooling ffhp_clg(m);
+
+  EXPECT_TRUE(ffhp_clg.setFuelType("Propane"));
+  EXPECT_TRUE(ffhp_clg.setEndUseSubcategory("AnyText"));
+  EXPECT_TRUE(ffhp_clg.setNominalCoolingCapacity(1.0));
+  EXPECT_TRUE(ffhp_clg.setNominalCOP(2.0));
+  EXPECT_TRUE(ffhp_clg.setDesignFlowRate(3.0));
+  EXPECT_TRUE(ffhp_clg.setDesignSupplyTemperature(4.0));
+  EXPECT_TRUE(ffhp_clg.setDesignTemperatureLift(5.0));
+  EXPECT_TRUE(ffhp_clg.setSizingFactor(6.0));
+  EXPECT_TRUE(ffhp_clg.setFlowMode("ConstantFlow"));
+  EXPECT_TRUE(ffhp_clg.setOutdoorAirTemperatureCurveInputVariable("WetBulb"));
+  EXPECT_TRUE(ffhp_clg.setWaterTemperatureCurveInputVariable("LeavingEvaporator"));
+  CurveBiquadratic curve8(m);
+  EXPECT_TRUE(ffhp_clg.setNormalizedCapacityFunctionofTemperatureCurve(curve8));
+  CurveBiquadratic curve9(m);
+  EXPECT_TRUE(ffhp_clg.setFuelEnergyInputRatioFunctionofTemperatureCurve(curve9));
+  CurveQuadratic curve10(m);
+  EXPECT_TRUE(ffhp_clg.setFuelEnergyInputRatioFunctionofPLRCurve(curve10));
+  EXPECT_TRUE(ffhp_clg.setMinimumPartLoadRatio(0.5));
+  EXPECT_TRUE(ffhp_clg.setMaximumPartLoadRatio(0.75));
+  CurveQuadratic curve11(m);
+  EXPECT_TRUE(ffhp_clg.setCyclingRatioFactorCurve(curve11));
+  EXPECT_TRUE(ffhp_clg.setNominalAuxiliaryElectricPower(12.0));
+  CurveBiquadratic curve12(m);
+  EXPECT_TRUE(ffhp_clg.setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(curve12));
+  CurveQuadratic curve13(m);
+  EXPECT_TRUE(ffhp_clg.setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(curve13));
+  EXPECT_TRUE(ffhp_clg.setStandbyElectricPower(13.0));
+
+  EXPECT_TRUE(ffhp_htg.setCompanionCoolingHeatPump(ffhp_clg));
+  EXPECT_TRUE(ffhp_clg.setCompanionHeatingHeatPump(ffhp_htg));
+
+  EXPECT_TRUE(plant_loop_ffhp_htg.addSupplyBranchForComponent(ffhp_htg));
+  EXPECT_TRUE(plant_loop_ffhp_clg.addSupplyBranchForComponent(ffhp_clg));
+
+  ForwardTranslator ft;
+  Workspace w = ft.translateModel(m);
+
+  EXPECT_EQ(1u, w.getObjectsByType(IddObjectType::HeatPump_AirToWater_FuelFired_Heating).size());
+  EXPECT_EQ(1u, w.getObjectsByType(IddObjectType::HeatPump_AirToWater_FuelFired_Cooling).size());
+  EXPECT_EQ(3u, w.getObjectsByType(IddObjectType::OutdoorAir_Node).size());
+  EXPECT_EQ(10u, w.getObjectsByType(IddObjectType::Curve_Biquadratic).size());
+  EXPECT_EQ(9u, w.getObjectsByType(IddObjectType::Curve_Quadratic).size());
+
+  IdfObject idf_ffhp_htg = w.getObjectsByType(IddObjectType::HeatPump_AirToWater_FuelFired_Heating)[0];
+
+  EXPECT_EQ(ffhp_htg.nameString(), idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::Name, false).get());
+  EXPECT_EQ(ffhp_htg.inletModelObject().get().nameString(),
+            idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::WaterInletNodeName, false).get());
+  EXPECT_EQ(ffhp_htg.outletModelObject().get().nameString(),
+            idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::WaterOutletNodeName, false).get());
+  EXPECT_EQ(ffhp_htg.nameString() + " OA Node", idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::AirSourceNodeName, false).get());
+  EXPECT_EQ(ffhp_clg.nameString(), idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::CompanionCoolingHeatPumpName, false).get());
+  EXPECT_EQ("Propane", idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::FuelType, false).get());
+  EXPECT_EQ("AnyText", idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::EndUseSubcategory, false).get());
+  EXPECT_EQ(1.0, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::NominalHeatingCapacity, false).get());
+  EXPECT_EQ(2.0, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::NominalCOP, false).get());
+  EXPECT_EQ(3.0, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::DesignFlowRate, false).get());
+  EXPECT_EQ(4.0, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::DesignSupplyTemperature, false).get());
+  EXPECT_EQ(5.0, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::DesignTemperatureLift, false).get());
+  EXPECT_EQ(6.0, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::SizingFactor, false).get());
+  EXPECT_EQ("ConstantFlow", idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::FlowMode, false).get());
+  EXPECT_EQ("WetBulb", idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::OutdoorAirTemperatureCurveInputVariable, false).get());
+  EXPECT_EQ("LeavingCondenser", idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::WaterTemperatureCurveInputVariable, false).get());
+  EXPECT_EQ(curve1.nameString(),
+            idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::NormalizedCapacityFunctionofTemperatureCurveName, false).get());
+  EXPECT_EQ(curve2.nameString(),
+            idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioFunctionofTemperatureCurveName, false).get());
+  EXPECT_EQ(curve3.nameString(),
+            idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioFunctionofPLRCurveName, false).get());
+  EXPECT_EQ(0.5, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::MinimumPartLoadRatio, false).get());
+  EXPECT_EQ(0.75, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::MaximumPartLoadRatio, false).get());
+  EXPECT_EQ("OnDemand", idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::DefrostControlType, false).get());
+  EXPECT_EQ(0.8, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::DefrostOperationTimeFraction, false).get());
+  EXPECT_EQ(curve4.nameString(),
+            idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioDefrostAdjustmentCurveName, false).get());
+  EXPECT_EQ(10.0, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::ResistiveDefrostHeaterCapacity, false).get());
+  EXPECT_EQ(9.9,
+            idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::MaximumOutdoorDrybulbTemperatureforDefrostOperation, false).get());
+  EXPECT_EQ(curve5.nameString(), idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::CyclingRatioFactorCurveName, false).get());
+  EXPECT_EQ(12.0, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::NominalAuxiliaryElectricPower, false).get());
+  EXPECT_EQ(
+    curve6.nameString(),
+    idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName, false)
+      .get());
+  EXPECT_EQ(
+    curve7.nameString(),
+    idf_ffhp_htg.getString(HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName, false).get());
+  EXPECT_EQ(13.0, idf_ffhp_htg.getDouble(HeatPump_AirToWater_FuelFired_HeatingFields::StandbyElectricPower, false).get());
+
+  IdfObject idf_ffhp_clg = w.getObjectsByType(IddObjectType::HeatPump_AirToWater_FuelFired_Cooling)[0];
+
+  EXPECT_EQ(ffhp_clg.nameString(), idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::Name, false).get());
+  EXPECT_EQ(ffhp_clg.inletModelObject().get().nameString(),
+            idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::WaterInletNodeName, false).get());
+  EXPECT_EQ(ffhp_clg.outletModelObject().get().nameString(),
+            idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::WaterOutletNodeName, false).get());
+  EXPECT_EQ(ffhp_clg.nameString() + " OA Node", idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::AirSourceNodeName, false).get());
+  EXPECT_EQ(ffhp_htg.nameString(), idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::CompanionHeatingHeatPumpName, false).get());
+  EXPECT_EQ("Propane", idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::FuelType, false).get());
+  EXPECT_EQ("AnyText", idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::EndUseSubcategory, false).get());
+  EXPECT_EQ(1.0, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::NominalCoolingCapacity, false).get());
+  EXPECT_EQ(2.0, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::NominalCOP, false).get());
+  EXPECT_EQ(3.0, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::DesignFlowRate, false).get());
+  EXPECT_EQ(4.0, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::DesignSupplyTemperature, false).get());
+  EXPECT_EQ(5.0, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::DesignTemperatureLift, false).get());
+  EXPECT_EQ(6.0, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::SizingFactor, false).get());
+  EXPECT_EQ("ConstantFlow", idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::FlowMode, false).get());
+  EXPECT_EQ("WetBulb", idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::OutdoorAirTemperatureCurveInputVariable, false).get());
+  EXPECT_EQ("LeavingEvaporator",
+            idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::WaterTemperatureCurveInputVariable, false).get());
+  EXPECT_EQ(curve8.nameString(),
+            idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::NormalizedCapacityFunctionofTemperatureCurveName, false).get());
+  EXPECT_EQ(curve9.nameString(),
+            idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::FuelEnergyInputRatioFunctionofTemperatureCurveName, false).get());
+  EXPECT_EQ(curve10.nameString(),
+            idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::FuelEnergyInputRatioFunctionofPLRCurveName, false).get());
+  EXPECT_EQ(0.5, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::MinimumPartLoadRatio, false).get());
+  EXPECT_EQ(0.75, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::MaximumPartLoadRatio, false).get());
+  EXPECT_EQ(curve11.nameString(), idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::CyclingRatioFactorCurveName, false).get());
+  EXPECT_EQ(12.0, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::NominalAuxiliaryElectricPower, false).get());
+  EXPECT_EQ(
+    curve12.nameString(),
+    idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName, false)
+      .get());
+  EXPECT_EQ(
+    curve13.nameString(),
+    idf_ffhp_clg.getString(HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName, false).get());
+  EXPECT_EQ(13.0, idf_ffhp_clg.getDouble(HeatPump_AirToWater_FuelFired_CoolingFields::StandbyElectricPower, false).get());
+}
diff --git a/src/energyplus/Test/PlantEquipmentOperationSchemes_GTest.cpp b/src/energyplus/Test/PlantEquipmentOperationSchemes_GTest.cpp
index 69c3b6b2980..6465b9f303a 100644
--- a/src/energyplus/Test/PlantEquipmentOperationSchemes_GTest.cpp
+++ b/src/energyplus/Test/PlantEquipmentOperationSchemes_GTest.cpp
@@ -62,6 +62,8 @@
 #include "../../model/GroundHeatExchangerHorizontalTrench.hpp"
 #include "../../model/GroundHeatExchangerVertical.hpp"
 #include "../../model/HeatExchangerFluidToFluid.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "../../model/HeatPumpAirToWaterFuelFiredCooling.hpp"
 #include "../../model/HeatPumpWaterToWaterEquationFitCooling.hpp"
 #include "../../model/HeatPumpWaterToWaterEquationFitHeating.hpp"
 #include "../../model/HeatPumpPlantLoopEIRCooling.hpp"
@@ -767,6 +769,16 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_PlantEquipmentOperationSchemes_compo
     EXPECT_EQ(ComponentType::COOLING, openstudio::energyplus::componentType(obj));
   }
 
+  {
+    HeatPumpAirToWaterFuelFiredHeating obj(m);
+    EXPECT_EQ(ComponentType::HEATING, openstudio::energyplus::componentType(obj));
+  }
+
+  {
+    HeatPumpAirToWaterFuelFiredCooling obj(m);
+    EXPECT_EQ(ComponentType::COOLING, openstudio::energyplus::componentType(obj));
+  }
+
   {
     GeneratorMicroTurbine chp(m);
     GeneratorMicroTurbineHeatRecovery obj(m, chp);
diff --git a/src/model/CMakeLists.txt b/src/model/CMakeLists.txt
index 92c864581a6..e9fa0111418 100644
--- a/src/model/CMakeLists.txt
+++ b/src/model/CMakeLists.txt
@@ -905,6 +905,12 @@ set(${target_name}_src
   HeatBalanceAlgorithm.hpp
   HeatBalanceAlgorithm_Impl.hpp
   HeatBalanceAlgorithm.cpp
+  HeatPumpAirToWaterFuelFiredHeating.hpp
+  HeatPumpAirToWaterFuelFiredHeating_Impl.hpp
+  HeatPumpAirToWaterFuelFiredHeating.cpp
+  HeatPumpAirToWaterFuelFiredCooling.hpp
+  HeatPumpAirToWaterFuelFiredCooling_Impl.hpp
+  HeatPumpAirToWaterFuelFiredCooling.cpp
   HeatPumpWaterToWaterEquationFitCooling.hpp
   HeatPumpWaterToWaterEquationFitCooling_Impl.hpp
   HeatPumpWaterToWaterEquationFitCooling.cpp
@@ -2128,6 +2134,8 @@ set(${target_name}_test_src
   test/HeatExchangerDesiccantBalancedFlow_GTest.cpp
   test/HeatExchangerDesiccantBalancedFlowPerformanceDataType1_GTest.cpp
   test/HeatExchangerFluidToFluid_GTest.cpp
+  test/HeatPumpAirToWaterFuelFiredHeating_GTest.cpp
+  test/HeatPumpAirToWaterFuelFiredCooling_GTest.cpp
   test/HeatPumpWaterToWaterEquationFitHeating_GTest.cpp
   test/HeatPumpWaterToWaterEquationFitCooling_GTest.cpp
   test/HeatPumpPlantLoopEIRHeating_GTest.cpp
diff --git a/src/model/ConcreteModelObjects.hpp b/src/model/ConcreteModelObjects.hpp
index d69360890bc..fb1e3c2e4e4 100644
--- a/src/model/ConcreteModelObjects.hpp
+++ b/src/model/ConcreteModelObjects.hpp
@@ -309,6 +309,8 @@
 #include "HeatExchangerDesiccantBalancedFlow.hpp"
 #include "HeatExchangerDesiccantBalancedFlowPerformanceDataType1.hpp"
 #include "HeatExchangerFluidToFluid.hpp"
+#include "HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "HeatPumpAirToWaterFuelFiredCooling.hpp"
 #include "HeatPumpWaterToWaterEquationFitCooling.hpp"
 #include "HeatPumpWaterToWaterEquationFitHeating.hpp"
 #include "HeatPumpPlantLoopEIRCooling.hpp"
@@ -858,6 +860,8 @@
 #include "HeatExchangerDesiccantBalancedFlow_Impl.hpp"
 #include "HeatExchangerDesiccantBalancedFlowPerformanceDataType1_Impl.hpp"
 #include "HeatExchangerFluidToFluid_Impl.hpp"
+#include "HeatPumpAirToWaterFuelFiredHeating_Impl.hpp"
+#include "HeatPumpAirToWaterFuelFiredCooling_Impl.hpp"
 #include "HeatPumpWaterToWaterEquationFitCooling_Impl.hpp"
 #include "HeatPumpWaterToWaterEquationFitHeating_Impl.hpp"
 #include "HeatPumpPlantLoopEIRCooling_Impl.hpp"
diff --git a/src/model/HeatPumpAirToWaterFuelFiredCooling.cpp b/src/model/HeatPumpAirToWaterFuelFiredCooling.cpp
new file mode 100644
index 00000000000..af6071391c5
--- /dev/null
+++ b/src/model/HeatPumpAirToWaterFuelFiredCooling.cpp
@@ -0,0 +1,928 @@
+/***********************************************************************************************************************
+*  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 "HeatPumpAirToWaterFuelFiredCooling.hpp"
+#include "HeatPumpAirToWaterFuelFiredCooling_Impl.hpp"
+
+#include "Model.hpp"
+#include "Curve.hpp"
+#include "Curve_Impl.hpp"
+#include "CurveBiquadratic.hpp"
+#include "CurveBiquadratic_Impl.hpp"
+#include "CurveQuadratic.hpp"
+#include "CurveQuadratic_Impl.hpp"
+#include "Node.hpp"
+#include "Node_Impl.hpp"
+#include "HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "HeatPumpAirToWaterFuelFiredHeating_Impl.hpp"
+
+#include <utilities/idd/IddFactory.hxx>
+#include <utilities/idd/IddEnums.hxx>
+#include <utilities/idd/OS_HeatPump_AirToWater_FuelFired_Cooling_FieldEnums.hxx>
+
+#include "../utilities/units/Unit.hpp"
+
+#include "../utilities/core/Assert.hpp"
+
+namespace openstudio {
+namespace model {
+
+  namespace detail {
+
+    HeatPumpAirToWaterFuelFiredCooling_Impl::HeatPumpAirToWaterFuelFiredCooling_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
+      : StraightComponent_Impl(idfObject, model, keepHandle) {
+      OS_ASSERT(idfObject.iddObject().type() == HeatPumpAirToWaterFuelFiredCooling::iddObjectType());
+    }
+
+    HeatPumpAirToWaterFuelFiredCooling_Impl::HeatPumpAirToWaterFuelFiredCooling_Impl(const openstudio::detail::WorkspaceObject_Impl& other,
+                                                                                     Model_Impl* model, bool keepHandle)
+      : StraightComponent_Impl(other, model, keepHandle) {
+      OS_ASSERT(other.iddObject().type() == HeatPumpAirToWaterFuelFiredCooling::iddObjectType());
+    }
+
+    HeatPumpAirToWaterFuelFiredCooling_Impl::HeatPumpAirToWaterFuelFiredCooling_Impl(const HeatPumpAirToWaterFuelFiredCooling_Impl& other,
+                                                                                     Model_Impl* model, bool keepHandle)
+      : StraightComponent_Impl(other, model, keepHandle) {}
+
+    const std::vector<std::string>& HeatPumpAirToWaterFuelFiredCooling_Impl::outputVariableNames() const {
+      static std::vector<std::string> result{"Fuel-fired Absorption HeatPump Load Side Heat Transfer Rate",
+                                             "Fuel-fired Absorption HeatPump Load Side Heat Transfer Energy",
+                                             "Fuel-fired Absorption HeatPump Inlet Temperature",
+                                             "Fuel-fired Absorption HeatPump Outlet Temperature",
+                                             "Fuel-fired Absorption HeatPump Fuel Rate",
+                                             "Fuel-fired Absorption HeatPump Electricity Rate",
+                                             "Fuel-fired Absorption HeatPump Fuel Energy",
+                                             "Fuel-fired Absorption HeatPump Electricity Energy",
+                                             "Fuel-fired Absorption HeatPump Mass Flow Rate",
+                                             "Fuel-fired Absorption HeatPump Volumetric Flow Rate"};
+      return result;
+    }
+
+    IddObjectType HeatPumpAirToWaterFuelFiredCooling_Impl::iddObjectType() const {
+      return HeatPumpAirToWaterFuelFiredCooling::iddObjectType();
+    }
+
+    unsigned HeatPumpAirToWaterFuelFiredCooling_Impl::inletPort() const {
+      return OS_HeatPump_AirToWater_FuelFired_CoolingFields::WaterInletNodeName;
+    }
+
+    unsigned HeatPumpAirToWaterFuelFiredCooling_Impl::outletPort() const {
+      return OS_HeatPump_AirToWater_FuelFired_CoolingFields::WaterOutletNodeName;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::addToNode(Node& node) {
+      if (boost::optional<PlantLoop> plant = node.plantLoop()) {
+        if (plant->supplyComponent(node.handle())) {
+          return StraightComponent_Impl::addToNode(node);
+        }
+      }
+
+      return false;
+    }
+
+    ModelObject HeatPumpAirToWaterFuelFiredCooling_Impl::clone(Model model) const {
+      auto moClone = StraightComponent_Impl::clone(model);
+      moClone.setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::CompanionHeatingHeatPumpName, "");
+      return moClone;
+    }
+
+    boost::optional<HeatPumpAirToWaterFuelFiredHeating> HeatPumpAirToWaterFuelFiredCooling_Impl::companionHeatingHeatPump() const {
+      return getObject<ModelObject>().getModelObjectTarget<HeatPumpAirToWaterFuelFiredHeating>(
+        OS_HeatPump_AirToWater_FuelFired_CoolingFields::CompanionHeatingHeatPumpName);
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredCooling_Impl::fuelType() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::FuelType, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredCooling_Impl::endUseSubcategory() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::EndUseSubcategory, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::isEndUseSubcategoryDefaulted() const {
+      return isEmpty(OS_HeatPump_AirToWater_FuelFired_CoolingFields::EndUseSubcategory);
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredCooling_Impl::nominalCoolingCapacity() const {
+      return getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NominalCoolingCapacity, true);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::isNominalCoolingCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NominalCoolingCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredCooling_Impl::autosizedNominalCoolingCapacity() {
+      return getAutosizedValue("Design Size Nominal Capacity", "W");
+    }
+
+    double HeatPumpAirToWaterFuelFiredCooling_Impl::nominalCOP() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NominalCOP, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredCooling_Impl::designFlowRate() const {
+      return getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignFlowRate, true);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::isDesignFlowRateAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignFlowRate, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredCooling_Impl::autosizedDesignFlowRate() {
+      return getAutosizedValue("Design Size Load Side Volume Flow Rate", "m3/s");
+    }
+
+    double HeatPumpAirToWaterFuelFiredCooling_Impl::designSupplyTemperature() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignSupplyTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredCooling_Impl::designTemperatureLift() const {
+      return getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignTemperatureLift, true);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::isDesignTemperatureLiftAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignTemperatureLift, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredCooling_Impl::autosizedDesignTemperatureLift() {
+      // TODO: This entire field is actually never used in E+ as of 23.1.0-IOFreeze
+      return getAutosizedValue("TODO_CHECK_SQL Design Temperature Lift", "deltaC");
+    }
+
+    double HeatPumpAirToWaterFuelFiredCooling_Impl::sizingFactor() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::SizingFactor, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredCooling_Impl::flowMode() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::FlowMode, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredCooling_Impl::outdoorAirTemperatureCurveInputVariable() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::OutdoorAirTemperatureCurveInputVariable, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredCooling_Impl::waterTemperatureCurveInputVariable() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::WaterTemperatureCurveInputVariable, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    Curve HeatPumpAirToWaterFuelFiredCooling_Impl::normalizedCapacityFunctionofTemperatureCurve() const {
+      boost::optional<Curve> value = optionalNormalizedCapacityFunctionofTemperatureCurve();
+      if (!value) {
+        LOG_AND_THROW(briefDescription() << " does not have an Normalized Capacity Function of Temperature Curve attached.");
+      }
+      return value.get();
+    }
+
+    Curve HeatPumpAirToWaterFuelFiredCooling_Impl::fuelEnergyInputRatioFunctionofTemperatureCurve() const {
+      boost::optional<Curve> value = optionalFuelEnergyInputRatioFunctionofTemperatureCurve();
+      if (!value) {
+        LOG_AND_THROW(briefDescription() << " does not have an Fuel Energy Input Ratio Function of Temperature Curve attached.");
+      }
+      return value.get();
+    }
+
+    Curve HeatPumpAirToWaterFuelFiredCooling_Impl::fuelEnergyInputRatioFunctionofPLRCurve() const {
+      boost::optional<Curve> value = optionalFuelEnergyInputRatioFunctionofPLRCurve();
+      if (!value) {
+        LOG_AND_THROW(briefDescription() << " does not have an Fuel Energy Input Ratio Function of PLR Curve attached.");
+      }
+      return value.get();
+    }
+
+    double HeatPumpAirToWaterFuelFiredCooling_Impl::minimumPartLoadRatio() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::MinimumPartLoadRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double HeatPumpAirToWaterFuelFiredCooling_Impl::maximumPartLoadRatio() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::MaximumPartLoadRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredCooling_Impl::cyclingRatioFactorCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(OS_HeatPump_AirToWater_FuelFired_CoolingFields::CyclingRatioFactorCurveName);
+    }
+
+    double HeatPumpAirToWaterFuelFiredCooling_Impl::nominalAuxiliaryElectricPower() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NominalAuxiliaryElectricPower, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredCooling_Impl::auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName);
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredCooling_Impl::auxiliaryElectricEnergyInputRatioFunctionofPLRCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName);
+    }
+
+    double HeatPumpAirToWaterFuelFiredCooling_Impl::standbyElectricPower() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::StandbyElectricPower, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setCompanionHeatingHeatPump(
+      const HeatPumpAirToWaterFuelFiredHeating& heatPumpAirToWaterFuelFiredHeating) {
+      bool result =
+        setPointer(OS_HeatPump_AirToWater_FuelFired_CoolingFields::CompanionHeatingHeatPumpName, heatPumpAirToWaterFuelFiredHeating.handle());
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::resetCompanionHeatingHeatPump() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::CompanionHeatingHeatPumpName, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setFuelType(const std::string& fuelType) {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::FuelType, fuelType);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setEndUseSubcategory(const std::string& endUseSubcategory) {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::EndUseSubcategory, endUseSubcategory);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::resetEndUseSubcategory() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::EndUseSubcategory, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setNominalCoolingCapacity(double nominalCoolingCapacity) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NominalCoolingCapacity, nominalCoolingCapacity);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::resetNominalCoolingCapacity() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NominalCoolingCapacity, "");
+      OS_ASSERT(result);
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::autosizeNominalCoolingCapacity() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NominalCoolingCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setNominalCOP(double nominalCOP) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NominalCOP, nominalCOP);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setDesignFlowRate(double designFlowRate) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignFlowRate, designFlowRate);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::resetDesignFlowRate() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignFlowRate, "");
+      OS_ASSERT(result);
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::autosizeDesignFlowRate() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignFlowRate, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setDesignSupplyTemperature(double designSupplyTemperature) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignSupplyTemperature, designSupplyTemperature);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setDesignTemperatureLift(double designTemperatureLift) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignTemperatureLift, designTemperatureLift);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::autosizeDesignTemperatureLift() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::DesignTemperatureLift, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setSizingFactor(double sizingFactor) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::SizingFactor, sizingFactor);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setFlowMode(const std::string& flowMode) {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::FlowMode, flowMode);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setOutdoorAirTemperatureCurveInputVariable(
+      const std::string& outdoorAirTemperatureCurveInputVariable) {
+      bool result =
+        setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::OutdoorAirTemperatureCurveInputVariable, outdoorAirTemperatureCurveInputVariable);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setWaterTemperatureCurveInputVariable(const std::string& waterTemperatureCurveInputVariable) {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::WaterTemperatureCurveInputVariable, waterTemperatureCurveInputVariable);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setNormalizedCapacityFunctionofTemperatureCurve(
+      const Curve& normalizedCapacityFunctionofTemperatureCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NormalizedCapacityFunctionofTemperatureCurveName,
+                               normalizedCapacityFunctionofTemperatureCurve.handle());
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setFuelEnergyInputRatioFunctionofTemperatureCurve(
+      const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_CoolingFields::FuelEnergyInputRatioFunctionofTemperatureCurveName,
+                               fuelEnergyInputRatioFunctionofTemperatureCurve.handle());
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setFuelEnergyInputRatioFunctionofPLRCurve(const Curve& fuelEnergyInputRatioFunctionofPLRCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_CoolingFields::FuelEnergyInputRatioFunctionofPLRCurveName,
+                               fuelEnergyInputRatioFunctionofPLRCurve.handle());
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setMinimumPartLoadRatio(double minimumPartLoadRatio) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::MinimumPartLoadRatio, minimumPartLoadRatio);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setMaximumPartLoadRatio(double maximumPartLoadRatio) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::MaximumPartLoadRatio, maximumPartLoadRatio);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setCyclingRatioFactorCurve(const Curve& cyclingRatioFactorCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_CoolingFields::CyclingRatioFactorCurveName, cyclingRatioFactorCurve.handle());
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::resetCyclingRatioFactorCurve() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::CyclingRatioFactorCurveName, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setNominalAuxiliaryElectricPower(double nominalAuxiliaryElectricPower) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::NominalAuxiliaryElectricPower, nominalAuxiliaryElectricPower);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(
+      const Curve& auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName,
+                               auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve.handle());
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(
+      const Curve& auxiliaryElectricEnergyInputRatioFunctionofPLRCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName,
+                               auxiliaryElectricEnergyInputRatioFunctionofPLRCurve.handle());
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_CoolingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredCooling_Impl::setStandbyElectricPower(double standbyElectricPower) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_CoolingFields::StandbyElectricPower, standbyElectricPower);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::autosize() {
+      autosizeNominalCoolingCapacity();
+      autosizeDesignFlowRate();
+      autosizeDesignTemperatureLift();
+    }
+
+    void HeatPumpAirToWaterFuelFiredCooling_Impl::applySizingValues() {
+      boost::optional<double> val;
+      val = autosizedNominalCoolingCapacity();
+      if (val) {
+        setNominalCoolingCapacity(val.get());
+      }
+
+      val = autosizedDesignFlowRate();
+      if (val) {
+        setDesignFlowRate(val.get());
+      }
+
+      val = autosizedDesignTemperatureLift();
+      if (val) {
+        setDesignTemperatureLift(val.get());
+      }
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredCooling_Impl::optionalNormalizedCapacityFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_CoolingFields::NormalizedCapacityFunctionofTemperatureCurveName);
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredCooling_Impl::optionalFuelEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_CoolingFields::FuelEnergyInputRatioFunctionofTemperatureCurveName);
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredCooling_Impl::optionalFuelEnergyInputRatioFunctionofPLRCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_CoolingFields::FuelEnergyInputRatioFunctionofPLRCurveName);
+    }
+
+  }  // namespace detail
+
+  HeatPumpAirToWaterFuelFiredCooling::HeatPumpAirToWaterFuelFiredCooling(const Model& model)
+    : StraightComponent(HeatPumpAirToWaterFuelFiredCooling::iddObjectType(), model) {
+    OS_ASSERT(getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>());
+
+    bool ok = setFuelType("NaturalGas");
+    OS_ASSERT(ok);
+    autosizeNominalCoolingCapacity();
+    ok = setNominalCOP(1.0);
+    OS_ASSERT(ok);
+    autosizeDesignFlowRate();
+    ok = setDesignSupplyTemperature(7.0);
+    OS_ASSERT(ok);
+    ok = setDesignTemperatureLift(11.1);
+    OS_ASSERT(ok);
+    ok = setSizingFactor(1.0);
+    OS_ASSERT(ok);
+    ok = setFlowMode("NotModulated");
+    OS_ASSERT(ok);
+    ok = setOutdoorAirTemperatureCurveInputVariable("DryBulb");
+    OS_ASSERT(ok);
+    ok = setWaterTemperatureCurveInputVariable("EnteringEvaporator");
+    OS_ASSERT(ok);
+
+    // From PlantLoopHeatPump_Fuel-Fired.idf
+
+    {
+      CurveBiquadratic normalizedCapacityFunctionofTemperatureCurve(model);
+      normalizedCapacityFunctionofTemperatureCurve.setName("GAHP Cooling CapFT");
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient1Constant(1);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient2x(0);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient3xPOW2(0);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient4y(0);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient5yPOW2(0);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient6xTIMESY(0);
+      normalizedCapacityFunctionofTemperatureCurve.setMinimumValueofx(5);
+      normalizedCapacityFunctionofTemperatureCurve.setMaximumValueofx(10);
+      normalizedCapacityFunctionofTemperatureCurve.setMinimumValueofy(24);
+      normalizedCapacityFunctionofTemperatureCurve.setMaximumValueofy(35);
+      normalizedCapacityFunctionofTemperatureCurve.setInputUnitTypeforX("Temperature");
+      normalizedCapacityFunctionofTemperatureCurve.setInputUnitTypeforY("Temperature");
+      ok = setNormalizedCapacityFunctionofTemperatureCurve(normalizedCapacityFunctionofTemperatureCurve);
+      OS_ASSERT(ok);
+    }
+
+    {
+      CurveBiquadratic fuelEnergyInputRatioFunctionofTemperatureCurve(model);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setName("GAHP Cooling EIRFT");
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient1Constant(1);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient2x(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient3xPOW2(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient4y(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient5yPOW2(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient6xTIMESY(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setMinimumValueofx(5);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setMaximumValueofx(10);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setMinimumValueofy(24);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setMaximumValueofy(35);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setInputUnitTypeforX("Temperature");
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setInputUnitTypeforY("Temperature");
+      ok = setFuelEnergyInputRatioFunctionofTemperatureCurve(fuelEnergyInputRatioFunctionofTemperatureCurve);
+      OS_ASSERT(ok);
+    }
+
+    {
+      CurveQuadratic fuelEnergyInputRatioFunctionofPLRCurve(model);
+      fuelEnergyInputRatioFunctionofPLRCurve.setName("GAHP Cooling EIRFPLR");
+      fuelEnergyInputRatioFunctionofPLRCurve.setCoefficient1Constant(1);
+      fuelEnergyInputRatioFunctionofPLRCurve.setCoefficient2x(0);
+      fuelEnergyInputRatioFunctionofPLRCurve.setCoefficient3xPOW2(0);
+      fuelEnergyInputRatioFunctionofPLRCurve.setMinimumValueofx(0);
+      fuelEnergyInputRatioFunctionofPLRCurve.setMaximumValueofx(1);
+      ok = setFuelEnergyInputRatioFunctionofPLRCurve(fuelEnergyInputRatioFunctionofPLRCurve);
+      OS_ASSERT(ok);
+    }
+
+    ok = setMinimumPartLoadRatio(0.1);
+    OS_ASSERT(ok);
+    ok = setMaximumPartLoadRatio(1.0);
+    OS_ASSERT(ok);
+    ok = setNominalAuxiliaryElectricPower(0);
+    OS_ASSERT(ok);
+    ok = setStandbyElectricPower(0);
+    OS_ASSERT(ok);
+  }
+
+  HeatPumpAirToWaterFuelFiredCooling::HeatPumpAirToWaterFuelFiredCooling(const Model& model,
+                                                                         const Curve& normalizedCapacityFunctionofTemperatureCurve,
+                                                                         const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve,
+                                                                         const Curve& fuelEnergyInputRatioFunctionofPLRCurve)
+    : StraightComponent(HeatPumpAirToWaterFuelFiredCooling::iddObjectType(), model) {
+    OS_ASSERT(getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>());
+
+    bool ok = true;
+    ok = setFuelType("NaturalGas");
+    OS_ASSERT(ok);
+    autosizeNominalCoolingCapacity();
+    ok = setNominalCOP(1.0);
+    OS_ASSERT(ok);
+    autosizeDesignFlowRate();
+    ok = setDesignSupplyTemperature(7.0);
+    OS_ASSERT(ok);
+    ok = setDesignTemperatureLift(11.1);
+    OS_ASSERT(ok);
+    ok = setSizingFactor(1.0);
+    OS_ASSERT(ok);
+    ok = setFlowMode("NotModulated");
+    OS_ASSERT(ok);
+    ok = setOutdoorAirTemperatureCurveInputVariable("DryBulb");
+    OS_ASSERT(ok);
+    ok = setWaterTemperatureCurveInputVariable("EnteringEvaporator");
+    OS_ASSERT(ok);
+
+    ok = setNormalizedCapacityFunctionofTemperatureCurve(normalizedCapacityFunctionofTemperatureCurve);
+    if (!ok) {
+      remove();
+      LOG_AND_THROW("Unable to set " << briefDescription() << "'s normalized capacity modifier function of temperature curve to "
+                                     << normalizedCapacityFunctionofTemperatureCurve.briefDescription() << ".");
+    }
+
+    ok = setFuelEnergyInputRatioFunctionofTemperatureCurve(fuelEnergyInputRatioFunctionofTemperatureCurve);
+    if (!ok) {
+      remove();
+      LOG_AND_THROW("Unable to set " << briefDescription() << "'s fuel energy input ratio function of temperature curve to "
+                                     << fuelEnergyInputRatioFunctionofTemperatureCurve.briefDescription() << ".");
+    }
+
+    ok = setFuelEnergyInputRatioFunctionofPLRCurve(fuelEnergyInputRatioFunctionofPLRCurve);
+    if (!ok) {
+      remove();
+      LOG_AND_THROW("Unable to set " << briefDescription() << "'s fuel energy input ratio function of PLR curve to "
+                                     << fuelEnergyInputRatioFunctionofPLRCurve.briefDescription() << ".");
+    }
+
+    ok = setMinimumPartLoadRatio(0.1);
+    OS_ASSERT(ok);
+    ok = setMaximumPartLoadRatio(1.0);
+    OS_ASSERT(ok);
+    ok = setNominalAuxiliaryElectricPower(0);
+    OS_ASSERT(ok);
+    ok = setStandbyElectricPower(0);
+    OS_ASSERT(ok);
+  }
+
+  IddObjectType HeatPumpAirToWaterFuelFiredCooling::iddObjectType() {
+    return {IddObjectType::OS_HeatPump_AirToWater_FuelFired_Cooling};
+  }
+
+  std::vector<std::string> HeatPumpAirToWaterFuelFiredCooling::fuelTypeValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_HeatPump_AirToWater_FuelFired_CoolingFields::FuelType);
+  }
+
+  std::vector<std::string> HeatPumpAirToWaterFuelFiredCooling::flowModeValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_HeatPump_AirToWater_FuelFired_CoolingFields::FlowMode);
+  }
+
+  std::vector<std::string> HeatPumpAirToWaterFuelFiredCooling::outdoorAirTemperatureCurveInputVariableValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
+                          OS_HeatPump_AirToWater_FuelFired_CoolingFields::OutdoorAirTemperatureCurveInputVariable);
+  }
+
+  std::vector<std::string> HeatPumpAirToWaterFuelFiredCooling::waterTemperatureCurveInputVariableValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
+                          OS_HeatPump_AirToWater_FuelFired_CoolingFields::WaterTemperatureCurveInputVariable);
+  }
+
+  boost::optional<HeatPumpAirToWaterFuelFiredHeating> HeatPumpAirToWaterFuelFiredCooling::companionHeatingHeatPump() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->companionHeatingHeatPump();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredCooling::fuelType() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->fuelType();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredCooling::endUseSubcategory() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->endUseSubcategory();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::isEndUseSubcategoryDefaulted() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->isEndUseSubcategoryDefaulted();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredCooling::nominalCoolingCapacity() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->nominalCoolingCapacity();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::isNominalCoolingCapacityAutosized() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->isNominalCoolingCapacityAutosized();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredCooling::autosizedNominalCoolingCapacity() {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->autosizedNominalCoolingCapacity();
+  }
+
+  double HeatPumpAirToWaterFuelFiredCooling::nominalCOP() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->nominalCOP();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredCooling::designFlowRate() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->designFlowRate();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::isDesignFlowRateAutosized() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->isDesignFlowRateAutosized();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredCooling::autosizedDesignFlowRate() {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->autosizedDesignFlowRate();
+  }
+
+  double HeatPumpAirToWaterFuelFiredCooling::designSupplyTemperature() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->designSupplyTemperature();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredCooling::designTemperatureLift() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->designTemperatureLift();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::isDesignTemperatureLiftAutosized() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->isDesignTemperatureLiftAutosized();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredCooling::autosizedDesignTemperatureLift() {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->autosizedDesignTemperatureLift();
+  }
+
+  double HeatPumpAirToWaterFuelFiredCooling::sizingFactor() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->sizingFactor();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredCooling::flowMode() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->flowMode();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredCooling::outdoorAirTemperatureCurveInputVariable() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->outdoorAirTemperatureCurveInputVariable();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredCooling::waterTemperatureCurveInputVariable() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->waterTemperatureCurveInputVariable();
+  }
+
+  Curve HeatPumpAirToWaterFuelFiredCooling::normalizedCapacityFunctionofTemperatureCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->normalizedCapacityFunctionofTemperatureCurve();
+  }
+
+  Curve HeatPumpAirToWaterFuelFiredCooling::fuelEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->fuelEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  Curve HeatPumpAirToWaterFuelFiredCooling::fuelEnergyInputRatioFunctionofPLRCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->fuelEnergyInputRatioFunctionofPLRCurve();
+  }
+
+  double HeatPumpAirToWaterFuelFiredCooling::minimumPartLoadRatio() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->minimumPartLoadRatio();
+  }
+
+  double HeatPumpAirToWaterFuelFiredCooling::maximumPartLoadRatio() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->maximumPartLoadRatio();
+  }
+
+  boost::optional<Curve> HeatPumpAirToWaterFuelFiredCooling::cyclingRatioFactorCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->cyclingRatioFactorCurve();
+  }
+
+  double HeatPumpAirToWaterFuelFiredCooling::nominalAuxiliaryElectricPower() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->nominalAuxiliaryElectricPower();
+  }
+
+  boost::optional<Curve> HeatPumpAirToWaterFuelFiredCooling::auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> HeatPumpAirToWaterFuelFiredCooling::auxiliaryElectricEnergyInputRatioFunctionofPLRCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->auxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+  }
+
+  double HeatPumpAirToWaterFuelFiredCooling::standbyElectricPower() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->standbyElectricPower();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setCompanionHeatingHeatPump(const HeatPumpAirToWaterFuelFiredHeating& heatPumpAirToWaterFuelFiredHeating) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setCompanionHeatingHeatPump(heatPumpAirToWaterFuelFiredHeating);
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::resetCompanionHeatingHeatPump() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->resetCompanionHeatingHeatPump();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setFuelType(const std::string& fuelType) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setFuelType(fuelType);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setEndUseSubcategory(const std::string& endUseSubcategory) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setEndUseSubcategory(endUseSubcategory);
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::resetEndUseSubcategory() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->resetEndUseSubcategory();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setNominalCoolingCapacity(double nominalCoolingCapacity) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setNominalCoolingCapacity(nominalCoolingCapacity);
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::resetNominalCoolingCapacity() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->resetNominalCoolingCapacity();
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::autosizeNominalCoolingCapacity() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->autosizeNominalCoolingCapacity();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setNominalCOP(double nominalCOP) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setNominalCOP(nominalCOP);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setDesignFlowRate(double designFlowRate) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setDesignFlowRate(designFlowRate);
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::resetDesignFlowRate() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->resetDesignFlowRate();
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::autosizeDesignFlowRate() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->autosizeDesignFlowRate();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setDesignSupplyTemperature(double designSupplyTemperature) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setDesignSupplyTemperature(designSupplyTemperature);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setDesignTemperatureLift(double designTemperatureLift) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setDesignTemperatureLift(designTemperatureLift);
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::autosizeDesignTemperatureLift() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->autosizeDesignTemperatureLift();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setSizingFactor(double sizingFactor) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setSizingFactor(sizingFactor);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setFlowMode(const std::string& flowMode) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setFlowMode(flowMode);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setOutdoorAirTemperatureCurveInputVariable(const std::string& outdoorAirTemperatureCurveInputVariable) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setOutdoorAirTemperatureCurveInputVariable(
+      outdoorAirTemperatureCurveInputVariable);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setWaterTemperatureCurveInputVariable(const std::string& waterTemperatureCurveInputVariable) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setWaterTemperatureCurveInputVariable(waterTemperatureCurveInputVariable);
+  }
+
+  bool
+    HeatPumpAirToWaterFuelFiredCooling::setNormalizedCapacityFunctionofTemperatureCurve(const Curve& normalizedCapacityFunctionofTemperatureCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setNormalizedCapacityFunctionofTemperatureCurve(
+      normalizedCapacityFunctionofTemperatureCurve);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setFuelEnergyInputRatioFunctionofTemperatureCurve(
+    const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setFuelEnergyInputRatioFunctionofTemperatureCurve(
+      fuelEnergyInputRatioFunctionofTemperatureCurve);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setFuelEnergyInputRatioFunctionofPLRCurve(const Curve& fuelEnergyInputRatioFunctionofPLRCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setFuelEnergyInputRatioFunctionofPLRCurve(
+      fuelEnergyInputRatioFunctionofPLRCurve);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setMinimumPartLoadRatio(double minimumPartLoadRatio) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setMinimumPartLoadRatio(minimumPartLoadRatio);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setMaximumPartLoadRatio(double maximumPartLoadRatio) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setMaximumPartLoadRatio(maximumPartLoadRatio);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setCyclingRatioFactorCurve(const Curve& cyclingRatioFactorCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setCyclingRatioFactorCurve(cyclingRatioFactorCurve);
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::resetCyclingRatioFactorCurve() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->resetCyclingRatioFactorCurve();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setNominalAuxiliaryElectricPower(double nominalAuxiliaryElectricPower) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setNominalAuxiliaryElectricPower(nominalAuxiliaryElectricPower);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(
+    const Curve& auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(
+      auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve);
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(
+    const Curve& auxiliaryElectricEnergyInputRatioFunctionofPLRCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(
+      auxiliaryElectricEnergyInputRatioFunctionofPLRCurve);
+  }
+
+  void HeatPumpAirToWaterFuelFiredCooling::resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredCooling::setStandbyElectricPower(double standbyElectricPower) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredCooling_Impl>()->setStandbyElectricPower(standbyElectricPower);
+  }
+
+  /// @cond
+  HeatPumpAirToWaterFuelFiredCooling::HeatPumpAirToWaterFuelFiredCooling(std::shared_ptr<detail::HeatPumpAirToWaterFuelFiredCooling_Impl> impl)
+    : StraightComponent(std::move(impl)) {}
+  /// @endcond
+
+}  // namespace model
+}  // namespace openstudio
diff --git a/src/model/HeatPumpAirToWaterFuelFiredCooling.hpp b/src/model/HeatPumpAirToWaterFuelFiredCooling.hpp
new file mode 100644
index 00000000000..a6588909218
--- /dev/null
+++ b/src/model/HeatPumpAirToWaterFuelFiredCooling.hpp
@@ -0,0 +1,246 @@
+/***********************************************************************************************************************
+*  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.
+***********************************************************************************************************************/
+
+#ifndef MODEL_HEATPUMPAIRTOWATERFUELFIREDCOOLING_HPP
+#define MODEL_HEATPUMPAIRTOWATERFUELFIREDCOOLING_HPP
+
+#include <model/ModelAPI.hpp>
+#include "StraightComponent.hpp"
+
+namespace openstudio {
+
+namespace model {
+
+  class HeatPumpAirToWaterFuelFiredHeating;
+  class Curve;
+  // class OutdoorAirNode;
+
+  namespace detail {
+
+    class HeatPumpAirToWaterFuelFiredCooling_Impl;
+
+  }  // namespace detail
+
+  /** HeatPumpAirToWaterFuelFiredCooling is a StraightComponent that wraps the OpenStudio IDD object 'OS:HeatPump:AirToWater:FuelFired:Cooling'. */
+  class MODEL_API HeatPumpAirToWaterFuelFiredCooling : public StraightComponent
+  {
+   public:
+    /** @name Constructors and Destructors */
+    //@{
+
+    explicit HeatPumpAirToWaterFuelFiredCooling(const Model& model);
+
+    explicit HeatPumpAirToWaterFuelFiredCooling(const Model& model, const Curve& normalizedCapacityFunctionofTemperatureCurve,
+                                                const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve,
+                                                const Curve& fuelEnergyInputRatioFunctionofPLRCurve);
+
+    virtual ~HeatPumpAirToWaterFuelFiredCooling() = default;
+    // Default the copy and move operators because the virtual dtor is explicit
+    HeatPumpAirToWaterFuelFiredCooling(const HeatPumpAirToWaterFuelFiredCooling& other) = default;
+    HeatPumpAirToWaterFuelFiredCooling(HeatPumpAirToWaterFuelFiredCooling&& other) = default;
+    HeatPumpAirToWaterFuelFiredCooling& operator=(const HeatPumpAirToWaterFuelFiredCooling&) = default;
+    HeatPumpAirToWaterFuelFiredCooling& operator=(HeatPumpAirToWaterFuelFiredCooling&&) = default;
+
+    //@}
+
+    static IddObjectType iddObjectType();
+
+    static std::vector<std::string> fuelTypeValues();
+
+    static std::vector<std::string> flowModeValues();
+
+    static std::vector<std::string> outdoorAirTemperatureCurveInputVariableValues();
+
+    static std::vector<std::string> waterTemperatureCurveInputVariableValues();
+
+    /** @name Getters */
+    //@{
+
+    // boost::optional<OutdoorAirNode> airSourceNode() const;
+
+    boost::optional<HeatPumpAirToWaterFuelFiredHeating> companionHeatingHeatPump() const;
+
+    std::string fuelType() const;
+
+    std::string endUseSubcategory() const;
+
+    bool isEndUseSubcategoryDefaulted() const;
+
+    boost::optional<double> nominalCoolingCapacity() const;
+
+    bool isNominalCoolingCapacityAutosized() const;
+
+    boost::optional<double> autosizedNominalCoolingCapacity();
+
+    double nominalCOP() const;
+
+    boost::optional<double> designFlowRate() const;
+
+    bool isDesignFlowRateAutosized() const;
+
+    boost::optional<double> autosizedDesignFlowRate();
+
+    double designSupplyTemperature() const;
+
+    boost::optional<double> designTemperatureLift() const;
+
+    bool isDesignTemperatureLiftAutosized() const;
+
+    boost::optional<double> autosizedDesignTemperatureLift();
+
+    double sizingFactor() const;
+
+    std::string flowMode() const;
+
+    std::string outdoorAirTemperatureCurveInputVariable() const;
+
+    std::string waterTemperatureCurveInputVariable() const;
+
+    Curve normalizedCapacityFunctionofTemperatureCurve() const;
+
+    Curve fuelEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    Curve fuelEnergyInputRatioFunctionofPLRCurve() const;
+
+    double minimumPartLoadRatio() const;
+
+    double maximumPartLoadRatio() const;
+
+    boost::optional<Curve> cyclingRatioFactorCurve() const;
+
+    double nominalAuxiliaryElectricPower() const;
+
+    boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofPLRCurve() const;
+
+    double standbyElectricPower() const;
+
+    //@}
+    /** @name Setters */
+    //@{
+
+    // bool setAirSourceNode(const OutdoorAirNode& outdoorAirNode);
+
+    // void resetAirSourceNode();
+
+    bool setCompanionHeatingHeatPump(const HeatPumpAirToWaterFuelFiredHeating& heatPumpAirToWaterFuelFiredHeating);
+
+    void resetCompanionHeatingHeatPump();
+
+    bool setFuelType(const std::string& fuelType);
+
+    bool setEndUseSubcategory(const std::string& endUseSubcategory);
+
+    void resetEndUseSubcategory();
+
+    bool setNominalCoolingCapacity(double nominalCoolingCapacity);
+
+    void resetNominalCoolingCapacity();
+
+    void autosizeNominalCoolingCapacity();
+
+    bool setNominalCOP(double nominalCOP);
+
+    bool setDesignFlowRate(double designFlowRate);
+
+    void resetDesignFlowRate();
+
+    void autosizeDesignFlowRate();
+
+    bool setDesignSupplyTemperature(double designSupplyTemperature);
+
+    bool setDesignTemperatureLift(double designTemperatureLift);
+
+    void autosizeDesignTemperatureLift();
+
+    bool setSizingFactor(double sizingFactor);
+
+    bool setFlowMode(const std::string& flowMode);
+
+    bool setOutdoorAirTemperatureCurveInputVariable(const std::string& outdoorAirTemperatureCurveInputVariable);
+
+    bool setWaterTemperatureCurveInputVariable(const std::string& waterTemperatureCurveInputVariable);
+
+    bool setNormalizedCapacityFunctionofTemperatureCurve(const Curve& normalizedCapacityFunctionofTemperatureCurve);
+
+    bool setFuelEnergyInputRatioFunctionofTemperatureCurve(const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve);
+
+    bool setFuelEnergyInputRatioFunctionofPLRCurve(const Curve& fuelEnergyInputRatioFunctionofPLRCurve);
+
+    bool setMinimumPartLoadRatio(double minimumPartLoadRatio);
+
+    bool setMaximumPartLoadRatio(double maximumPartLoadRatio);
+
+    bool setCyclingRatioFactorCurve(const Curve& cyclingRatioFactorCurve);
+
+    void resetCyclingRatioFactorCurve();
+
+    bool setNominalAuxiliaryElectricPower(double nominalAuxiliaryElectricPower);
+
+    bool setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(const Curve& auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve);
+
+    void resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+
+    bool setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(const Curve& auxiliaryElectricEnergyInputRatioFunctionofPLRCurve);
+
+    void resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+
+    bool setStandbyElectricPower(double standbyElectricPower);
+
+    //@}
+    /** @name Other */
+    //@{
+
+    //@}
+   protected:
+    /// @cond
+    using ImplType = detail::HeatPumpAirToWaterFuelFiredCooling_Impl;
+
+    explicit HeatPumpAirToWaterFuelFiredCooling(std::shared_ptr<detail::HeatPumpAirToWaterFuelFiredCooling_Impl> impl);
+
+    friend class detail::HeatPumpAirToWaterFuelFiredCooling_Impl;
+    friend class Model;
+    friend class IdfObject;
+    friend class openstudio::detail::IdfObject_Impl;
+    /// @endcond
+   private:
+    REGISTER_LOGGER("openstudio.model.HeatPumpAirToWaterFuelFiredCooling");
+  };
+
+  /** \relates HeatPumpAirToWaterFuelFiredCooling*/
+  using OptionalHeatPumpAirToWaterFuelFiredCooling = boost::optional<HeatPumpAirToWaterFuelFiredCooling>;
+
+  /** \relates HeatPumpAirToWaterFuelFiredCooling*/
+  using HeatPumpAirToWaterFuelFiredCoolingVector = std::vector<HeatPumpAirToWaterFuelFiredCooling>;
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_HEATPUMPAIRTOWATERFUELFIREDCOOLING_HPP
diff --git a/src/model/HeatPumpAirToWaterFuelFiredCooling_Impl.hpp b/src/model/HeatPumpAirToWaterFuelFiredCooling_Impl.hpp
new file mode 100644
index 00000000000..5b894114159
--- /dev/null
+++ b/src/model/HeatPumpAirToWaterFuelFiredCooling_Impl.hpp
@@ -0,0 +1,236 @@
+/***********************************************************************************************************************
+*  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.
+***********************************************************************************************************************/
+
+#ifndef MODEL_HEATPUMPAIRTOWATERFUELFIREDCOOLING_IMPL_HPP
+#define MODEL_HEATPUMPAIRTOWATERFUELFIREDCOOLING_IMPL_HPP
+
+#include <model/ModelAPI.hpp>
+#include "StraightComponent_Impl.hpp"
+
+namespace openstudio {
+namespace model {
+
+  class HeatPumpAirToWaterFuelFiredHeating;
+  class Curve;
+  // class OutdoorAirNode;
+
+  namespace detail {
+
+    /** HeatPumpAirToWaterFuelFiredCooling_Impl is a StraightComponent_Impl that is the implementation class for HeatPumpAirToWaterFuelFiredCooling.*/
+    class MODEL_API HeatPumpAirToWaterFuelFiredCooling_Impl : public StraightComponent_Impl
+    {
+     public:
+      /** @name Constructors and Destructors */
+      //@{
+
+      HeatPumpAirToWaterFuelFiredCooling_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle);
+
+      HeatPumpAirToWaterFuelFiredCooling_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle);
+
+      HeatPumpAirToWaterFuelFiredCooling_Impl(const HeatPumpAirToWaterFuelFiredCooling_Impl& other, Model_Impl* model, bool keepHandle);
+
+      virtual ~HeatPumpAirToWaterFuelFiredCooling_Impl() {}
+
+      //@}
+      /** @name Virtual Methods */
+      //@{
+
+      virtual const std::vector<std::string>& outputVariableNames() const override;
+
+      virtual IddObjectType iddObjectType() const override;
+
+      virtual unsigned inletPort() const override;
+
+      virtual unsigned outletPort() const override;
+
+      virtual void autosize() override;
+
+      virtual void applySizingValues() override;
+
+      virtual bool addToNode(Node& node) override;
+
+      // Resets the Companion Heat Pump
+      virtual ModelObject clone(Model model) const override;
+
+      //@}
+      /** @name Getters */
+      //@{
+
+      // boost::optional<OutdoorAirNode> airSourceNode() const;
+
+      boost::optional<HeatPumpAirToWaterFuelFiredHeating> companionHeatingHeatPump() const;
+
+      std::string fuelType() const;
+
+      std::string endUseSubcategory() const;
+
+      bool isEndUseSubcategoryDefaulted() const;
+
+      boost::optional<double> nominalCoolingCapacity() const;
+
+      bool isNominalCoolingCapacityAutosized() const;
+
+      boost::optional<double> autosizedNominalCoolingCapacity();
+
+      double nominalCOP() const;
+
+      boost::optional<double> designFlowRate() const;
+
+      bool isDesignFlowRateAutosized() const;
+
+      boost::optional<double> autosizedDesignFlowRate();
+
+      double designSupplyTemperature() const;
+
+      boost::optional<double> designTemperatureLift() const;
+
+      bool isDesignTemperatureLiftAutosized() const;
+
+      boost::optional<double> autosizedDesignTemperatureLift();
+
+      double sizingFactor() const;
+
+      std::string flowMode() const;
+
+      std::string outdoorAirTemperatureCurveInputVariable() const;
+
+      std::string waterTemperatureCurveInputVariable() const;
+
+      Curve normalizedCapacityFunctionofTemperatureCurve() const;
+
+      Curve fuelEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      Curve fuelEnergyInputRatioFunctionofPLRCurve() const;
+
+      double minimumPartLoadRatio() const;
+
+      double maximumPartLoadRatio() const;
+
+      boost::optional<Curve> cyclingRatioFactorCurve() const;
+
+      double nominalAuxiliaryElectricPower() const;
+
+      boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofPLRCurve() const;
+
+      double standbyElectricPower() const;
+
+      //@}
+      /** @name Setters */
+      //@{
+
+      // bool setAirSourceNode(const OutdoorAirNode& outdoorAirNode);
+
+      // void resetAirSourceNode();
+
+      bool setCompanionHeatingHeatPump(const HeatPumpAirToWaterFuelFiredHeating& heatPumpAirToWaterFuelFiredHeating);
+
+      void resetCompanionHeatingHeatPump();
+
+      bool setFuelType(const std::string& fuelType);
+
+      bool setEndUseSubcategory(const std::string& endUseSubcategory);
+
+      void resetEndUseSubcategory();
+
+      bool setNominalCoolingCapacity(double nominalCoolingCapacity);
+
+      void resetNominalCoolingCapacity();
+
+      void autosizeNominalCoolingCapacity();
+
+      bool setNominalCOP(double nominalCOP);
+
+      bool setDesignFlowRate(double designFlowRate);
+
+      void resetDesignFlowRate();
+
+      void autosizeDesignFlowRate();
+
+      bool setDesignSupplyTemperature(double designSupplyTemperature);
+
+      bool setDesignTemperatureLift(double designTemperatureLift);
+
+      void autosizeDesignTemperatureLift();
+
+      bool setSizingFactor(double sizingFactor);
+
+      bool setFlowMode(const std::string& flowMode);
+
+      bool setOutdoorAirTemperatureCurveInputVariable(const std::string& outdoorAirTemperatureCurveInputVariable);
+
+      bool setWaterTemperatureCurveInputVariable(const std::string& waterTemperatureCurveInputVariable);
+
+      bool setNormalizedCapacityFunctionofTemperatureCurve(const Curve& normalizedCapacityFunctionofTemperatureCurve);
+
+      bool setFuelEnergyInputRatioFunctionofTemperatureCurve(const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve);
+
+      bool setFuelEnergyInputRatioFunctionofPLRCurve(const Curve& fuelEnergyInputRatioFunctionofPLRCurve);
+
+      bool setMinimumPartLoadRatio(double minimumPartLoadRatio);
+
+      bool setMaximumPartLoadRatio(double maximumPartLoadRatio);
+
+      bool setCyclingRatioFactorCurve(const Curve& cyclingRatioFactorCurve);
+
+      void resetCyclingRatioFactorCurve();
+
+      bool setNominalAuxiliaryElectricPower(double nominalAuxiliaryElectricPower);
+
+      bool setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(const Curve& auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve);
+
+      void resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+
+      bool setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(const Curve& auxiliaryElectricEnergyInputRatioFunctionofPLRCurve);
+
+      void resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+
+      bool setStandbyElectricPower(double standbyElectricPower);
+
+      //@}
+      /** @name Other */
+      //@{
+
+      //@}
+     protected:
+     private:
+      REGISTER_LOGGER("openstudio.model.HeatPumpAirToWaterFuelFiredCooling");
+
+      boost::optional<Curve> optionalNormalizedCapacityFunctionofTemperatureCurve() const;
+      boost::optional<Curve> optionalFuelEnergyInputRatioFunctionofTemperatureCurve() const;
+      boost::optional<Curve> optionalFuelEnergyInputRatioFunctionofPLRCurve() const;
+    };
+
+  }  // namespace detail
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_HEATPUMPAIRTOWATERFUELFIREDCOOLING_IMPL_HPP
diff --git a/src/model/HeatPumpAirToWaterFuelFiredHeating.cpp b/src/model/HeatPumpAirToWaterFuelFiredHeating.cpp
new file mode 100644
index 00000000000..d276c8af169
--- /dev/null
+++ b/src/model/HeatPumpAirToWaterFuelFiredHeating.cpp
@@ -0,0 +1,1060 @@
+/***********************************************************************************************************************
+*  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 "HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "HeatPumpAirToWaterFuelFiredHeating_Impl.hpp"
+
+#include "Model.hpp"
+#include "Curve.hpp"
+#include "Curve_Impl.hpp"
+#include "CurveBiquadratic.hpp"
+#include "CurveBiquadratic_Impl.hpp"
+#include "CurveQuadratic.hpp"
+#include "CurveQuadratic_Impl.hpp"
+#include "Node.hpp"
+#include "Node_Impl.hpp"
+#include "HeatPumpAirToWaterFuelFiredCooling.hpp"
+#include "HeatPumpAirToWaterFuelFiredCooling_Impl.hpp"
+
+#include <utilities/idd/IddFactory.hxx>
+#include <utilities/idd/IddEnums.hxx>
+#include <utilities/idd/OS_HeatPump_AirToWater_FuelFired_Heating_FieldEnums.hxx>
+
+#include "../utilities/units/Unit.hpp"
+
+#include "../utilities/core/Assert.hpp"
+
+namespace openstudio {
+namespace model {
+
+  namespace detail {
+
+    HeatPumpAirToWaterFuelFiredHeating_Impl::HeatPumpAirToWaterFuelFiredHeating_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
+      : StraightComponent_Impl(idfObject, model, keepHandle) {
+      OS_ASSERT(idfObject.iddObject().type() == HeatPumpAirToWaterFuelFiredHeating::iddObjectType());
+    }
+
+    HeatPumpAirToWaterFuelFiredHeating_Impl::HeatPumpAirToWaterFuelFiredHeating_Impl(const openstudio::detail::WorkspaceObject_Impl& other,
+                                                                                     Model_Impl* model, bool keepHandle)
+      : StraightComponent_Impl(other, model, keepHandle) {
+      OS_ASSERT(other.iddObject().type() == HeatPumpAirToWaterFuelFiredHeating::iddObjectType());
+    }
+
+    HeatPumpAirToWaterFuelFiredHeating_Impl::HeatPumpAirToWaterFuelFiredHeating_Impl(const HeatPumpAirToWaterFuelFiredHeating_Impl& other,
+                                                                                     Model_Impl* model, bool keepHandle)
+      : StraightComponent_Impl(other, model, keepHandle) {}
+
+    const std::vector<std::string>& HeatPumpAirToWaterFuelFiredHeating_Impl::outputVariableNames() const {
+      static std::vector<std::string> result{"Fuel-fired Absorption HeatPump Load Side Heat Transfer Rate",
+                                             "Fuel-fired Absorption HeatPump Load Side Heat Transfer Energy",
+                                             "Fuel-fired Absorption HeatPump Inlet Temperature",
+                                             "Fuel-fired Absorption HeatPump Outlet Temperature",
+                                             "Fuel-fired Absorption HeatPump Fuel Rate",
+                                             "Fuel-fired Absorption HeatPump Electricity Rate",
+                                             "Fuel-fired Absorption HeatPump Fuel Energy",
+                                             "Fuel-fired Absorption HeatPump Electricity Energy",
+                                             "Fuel-fired Absorption HeatPump Mass Flow Rate",
+                                             "Fuel-fired Absorption HeatPump Volumetric Flow Rate"};
+      return result;
+    }
+
+    IddObjectType HeatPumpAirToWaterFuelFiredHeating_Impl::iddObjectType() const {
+      return HeatPumpAirToWaterFuelFiredHeating::iddObjectType();
+    }
+
+    unsigned HeatPumpAirToWaterFuelFiredHeating_Impl::inletPort() const {
+      return OS_HeatPump_AirToWater_FuelFired_HeatingFields::WaterInletNodeName;
+    }
+
+    unsigned HeatPumpAirToWaterFuelFiredHeating_Impl::outletPort() const {
+      return OS_HeatPump_AirToWater_FuelFired_HeatingFields::WaterOutletNodeName;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::addToNode(Node& node) {
+      if (boost::optional<PlantLoop> plant = node.plantLoop()) {
+        if (plant->supplyComponent(node.handle())) {
+          return StraightComponent_Impl::addToNode(node);
+        }
+      }
+
+      return false;
+    }
+
+    ModelObject HeatPumpAirToWaterFuelFiredHeating_Impl::clone(Model model) const {
+      auto moClone = StraightComponent_Impl::clone(model);
+      moClone.setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::CompanionCoolingHeatPumpName, "");
+      return moClone;
+    }
+
+    boost::optional<HeatPumpAirToWaterFuelFiredCooling> HeatPumpAirToWaterFuelFiredHeating_Impl::companionCoolingHeatPump() const {
+      return getObject<ModelObject>().getModelObjectTarget<HeatPumpAirToWaterFuelFiredCooling>(
+        OS_HeatPump_AirToWater_FuelFired_HeatingFields::CompanionCoolingHeatPumpName);
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredHeating_Impl::fuelType() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelType, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredHeating_Impl::endUseSubcategory() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::EndUseSubcategory, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::isEndUseSubcategoryDefaulted() const {
+      return isEmpty(OS_HeatPump_AirToWater_FuelFired_HeatingFields::EndUseSubcategory);
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredHeating_Impl::nominalHeatingCapacity() const {
+      return getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NominalHeatingCapacity, true);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::isNominalHeatingCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NominalHeatingCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredHeating_Impl::autosizedNominalHeatingCapacity() {
+      return getAutosizedValue("Design Size Nominal Capacity", "W");
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::nominalCOP() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NominalCOP, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredHeating_Impl::designFlowRate() const {
+      return getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignFlowRate, true);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::isDesignFlowRateAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignFlowRate, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredHeating_Impl::autosizedDesignFlowRate() {
+      return getAutosizedValue("Design Size Load Side Volume Flow Rate", "m3/s");
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::designSupplyTemperature() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignSupplyTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredHeating_Impl::designTemperatureLift() const {
+      return getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignTemperatureLift, true);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::isDesignTemperatureLiftAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignTemperatureLift, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> HeatPumpAirToWaterFuelFiredHeating_Impl::autosizedDesignTemperatureLift() {
+      // TODO: This entire field is actually never used in E+ as of 23.1.0-IOFreeze
+      return getAutosizedValue("TODO_CHECK_SQL Design Temperature Lift", "deltaC");
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::sizingFactor() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::SizingFactor, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredHeating_Impl::flowMode() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::FlowMode, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredHeating_Impl::outdoorAirTemperatureCurveInputVariable() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::OutdoorAirTemperatureCurveInputVariable, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredHeating_Impl::waterTemperatureCurveInputVariable() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::WaterTemperatureCurveInputVariable, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    Curve HeatPumpAirToWaterFuelFiredHeating_Impl::normalizedCapacityFunctionofTemperatureCurve() const {
+      boost::optional<Curve> value = optionalNormalizedCapacityFunctionofTemperatureCurve();
+      if (!value) {
+        LOG_AND_THROW(briefDescription() << " does not have an Normalized Capacity Function of Temperature Curve attached.");
+      }
+      return value.get();
+    }
+
+    Curve HeatPumpAirToWaterFuelFiredHeating_Impl::fuelEnergyInputRatioFunctionofTemperatureCurve() const {
+      boost::optional<Curve> value = optionalFuelEnergyInputRatioFunctionofTemperatureCurve();
+      if (!value) {
+        LOG_AND_THROW(briefDescription() << " does not have an Fuel Energy Input Ratio Function of Temperature Curve attached.");
+      }
+      return value.get();
+    }
+
+    Curve HeatPumpAirToWaterFuelFiredHeating_Impl::fuelEnergyInputRatioFunctionofPLRCurve() const {
+      boost::optional<Curve> value = optionalFuelEnergyInputRatioFunctionofPLRCurve();
+      if (!value) {
+        LOG_AND_THROW(briefDescription() << " does not have an Fuel Energy Input Ratio Function of PLR Curve attached.");
+      }
+      return value.get();
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::minimumPartLoadRatio() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::MinimumPartLoadRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::maximumPartLoadRatio() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::MaximumPartLoadRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string HeatPumpAirToWaterFuelFiredHeating_Impl::defrostControlType() const {
+      boost::optional<std::string> value = getString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DefrostControlType, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::defrostOperationTimeFraction() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DefrostOperationTimeFraction, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating_Impl::fuelEnergyInputRatioDefrostAdjustmentCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioDefrostAdjustmentCurveName);
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::resistiveDefrostHeaterCapacity() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::ResistiveDefrostHeaterCapacity, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::maximumOutdoorDrybulbTemperatureforDefrostOperation() const {
+      boost::optional<double> value =
+        getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::MaximumOutdoorDrybulbTemperatureforDefrostOperation, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating_Impl::cyclingRatioFactorCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(OS_HeatPump_AirToWater_FuelFired_HeatingFields::CyclingRatioFactorCurveName);
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::nominalAuxiliaryElectricPower() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NominalAuxiliaryElectricPower, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating_Impl::auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName);
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating_Impl::auxiliaryElectricEnergyInputRatioFunctionofPLRCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName);
+    }
+
+    double HeatPumpAirToWaterFuelFiredHeating_Impl::standbyElectricPower() const {
+      boost::optional<double> value = getDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::StandbyElectricPower, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setCompanionCoolingHeatPump(
+      const HeatPumpAirToWaterFuelFiredCooling& heatPumpAirToWaterFuelFiredCooling) {
+      bool result =
+        setPointer(OS_HeatPump_AirToWater_FuelFired_HeatingFields::CompanionCoolingHeatPumpName, heatPumpAirToWaterFuelFiredCooling.handle());
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::resetCompanionCoolingHeatPump() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::CompanionCoolingHeatPumpName, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setFuelType(const std::string& fuelType) {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelType, fuelType);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setEndUseSubcategory(const std::string& endUseSubcategory) {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::EndUseSubcategory, endUseSubcategory);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::resetEndUseSubcategory() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::EndUseSubcategory, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setNominalHeatingCapacity(double nominalHeatingCapacity) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NominalHeatingCapacity, nominalHeatingCapacity);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::resetNominalHeatingCapacity() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NominalHeatingCapacity, "");
+      OS_ASSERT(result);
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::autosizeNominalHeatingCapacity() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NominalHeatingCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setNominalCOP(double nominalCOP) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NominalCOP, nominalCOP);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setDesignFlowRate(double designFlowRate) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignFlowRate, designFlowRate);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::resetDesignFlowRate() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignFlowRate, "");
+      OS_ASSERT(result);
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::autosizeDesignFlowRate() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignFlowRate, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setDesignSupplyTemperature(double designSupplyTemperature) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignSupplyTemperature, designSupplyTemperature);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setDesignTemperatureLift(double designTemperatureLift) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignTemperatureLift, designTemperatureLift);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::autosizeDesignTemperatureLift() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DesignTemperatureLift, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setSizingFactor(double sizingFactor) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::SizingFactor, sizingFactor);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setFlowMode(const std::string& flowMode) {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::FlowMode, flowMode);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setOutdoorAirTemperatureCurveInputVariable(
+      const std::string& outdoorAirTemperatureCurveInputVariable) {
+      bool result =
+        setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::OutdoorAirTemperatureCurveInputVariable, outdoorAirTemperatureCurveInputVariable);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setWaterTemperatureCurveInputVariable(const std::string& waterTemperatureCurveInputVariable) {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::WaterTemperatureCurveInputVariable, waterTemperatureCurveInputVariable);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setNormalizedCapacityFunctionofTemperatureCurve(
+      const Curve& normalizedCapacityFunctionofTemperatureCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NormalizedCapacityFunctionofTemperatureCurveName,
+                               normalizedCapacityFunctionofTemperatureCurve.handle());
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setFuelEnergyInputRatioFunctionofTemperatureCurve(
+      const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioFunctionofTemperatureCurveName,
+                               fuelEnergyInputRatioFunctionofTemperatureCurve.handle());
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setFuelEnergyInputRatioFunctionofPLRCurve(const Curve& fuelEnergyInputRatioFunctionofPLRCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioFunctionofPLRCurveName,
+                               fuelEnergyInputRatioFunctionofPLRCurve.handle());
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setMinimumPartLoadRatio(double minimumPartLoadRatio) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::MinimumPartLoadRatio, minimumPartLoadRatio);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setMaximumPartLoadRatio(double maximumPartLoadRatio) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::MaximumPartLoadRatio, maximumPartLoadRatio);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setDefrostControlType(const std::string& defrostControlType) {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DefrostControlType, defrostControlType);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setDefrostOperationTimeFraction(double defrostOperationTimeFraction) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::DefrostOperationTimeFraction, defrostOperationTimeFraction);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setFuelEnergyInputRatioDefrostAdjustmentCurve(
+      const Curve& fuelEnergyInputRatioDefrostAdjustmentCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioDefrostAdjustmentCurveName,
+                               fuelEnergyInputRatioDefrostAdjustmentCurve.handle());
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::resetFuelEnergyInputRatioDefrostAdjustmentCurve() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioDefrostAdjustmentCurveName, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setResistiveDefrostHeaterCapacity(double resistiveDefrostHeaterCapacity) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::ResistiveDefrostHeaterCapacity, resistiveDefrostHeaterCapacity);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setMaximumOutdoorDrybulbTemperatureforDefrostOperation(
+      double maximumOutdoorDrybulbTemperatureforDefrostOperation) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::MaximumOutdoorDrybulbTemperatureforDefrostOperation,
+                              maximumOutdoorDrybulbTemperatureforDefrostOperation);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setCyclingRatioFactorCurve(const Curve& cyclingRatioFactorCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_HeatingFields::CyclingRatioFactorCurveName, cyclingRatioFactorCurve.handle());
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::resetCyclingRatioFactorCurve() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::CyclingRatioFactorCurveName, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setNominalAuxiliaryElectricPower(double nominalAuxiliaryElectricPower) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::NominalAuxiliaryElectricPower, nominalAuxiliaryElectricPower);
+      return result;
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(
+      const Curve& auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName,
+                               auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve.handle());
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurveName, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(
+      const Curve& auxiliaryElectricEnergyInputRatioFunctionofPLRCurve) {
+      bool result = setPointer(OS_HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName,
+                               auxiliaryElectricEnergyInputRatioFunctionofPLRCurve.handle());
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve() {
+      bool result = setString(OS_HeatPump_AirToWater_FuelFired_HeatingFields::AuxiliaryElectricEnergyInputRatioFunctionofPLRCurveName, "");
+      OS_ASSERT(result);
+    }
+
+    bool HeatPumpAirToWaterFuelFiredHeating_Impl::setStandbyElectricPower(double standbyElectricPower) {
+      bool result = setDouble(OS_HeatPump_AirToWater_FuelFired_HeatingFields::StandbyElectricPower, standbyElectricPower);
+      return result;
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::autosize() {
+      autosizeNominalHeatingCapacity();
+      autosizeDesignFlowRate();
+      autosizeDesignTemperatureLift();
+    }
+
+    void HeatPumpAirToWaterFuelFiredHeating_Impl::applySizingValues() {
+      boost::optional<double> val;
+      val = autosizedNominalHeatingCapacity();
+      if (val) {
+        setNominalHeatingCapacity(val.get());
+      }
+
+      val = autosizedDesignFlowRate();
+      if (val) {
+        setDesignFlowRate(val.get());
+      }
+
+      val = autosizedDesignTemperatureLift();
+      if (val) {
+        setDesignTemperatureLift(val.get());
+      }
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating_Impl::optionalNormalizedCapacityFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_HeatingFields::NormalizedCapacityFunctionofTemperatureCurveName);
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating_Impl::optionalFuelEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioFunctionofTemperatureCurveName);
+    }
+
+    boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating_Impl::optionalFuelEnergyInputRatioFunctionofPLRCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelEnergyInputRatioFunctionofPLRCurveName);
+    }
+
+  }  // namespace detail
+
+  HeatPumpAirToWaterFuelFiredHeating::HeatPumpAirToWaterFuelFiredHeating(const Model& model)
+    : StraightComponent(HeatPumpAirToWaterFuelFiredHeating::iddObjectType(), model) {
+    OS_ASSERT(getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>());
+
+    bool ok = true;
+    ok = setFuelType("NaturalGas");
+    OS_ASSERT(ok);
+    autosizeNominalHeatingCapacity();
+    ok = setNominalCOP(1.0);
+    OS_ASSERT(ok);
+    autosizeDesignFlowRate();
+    ok = setDesignSupplyTemperature(60);
+    OS_ASSERT(ok);
+    ok = setDesignTemperatureLift(11.1);
+    OS_ASSERT(ok);
+    ok = setSizingFactor(1.0);
+    OS_ASSERT(ok);
+    ok = setFlowMode("NotModulated");
+    OS_ASSERT(ok);
+    ok = setOutdoorAirTemperatureCurveInputVariable("DryBulb");
+    OS_ASSERT(ok);
+    ok = setWaterTemperatureCurveInputVariable("EnteringCondenser");
+    OS_ASSERT(ok);
+
+    // From PlantLoopHeatPump_Fuel-Fired.idf
+
+    {
+      CurveBiquadratic normalizedCapacityFunctionofTemperatureCurve(model);
+      normalizedCapacityFunctionofTemperatureCurve.setName("GAHP Heating CapFT");
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient1Constant(1);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient2x(0);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient3xPOW2(0);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient4y(0);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient5yPOW2(0);
+      normalizedCapacityFunctionofTemperatureCurve.setCoefficient6xTIMESY(0);
+      normalizedCapacityFunctionofTemperatureCurve.setMinimumValueofx(5);
+      normalizedCapacityFunctionofTemperatureCurve.setMaximumValueofx(10);
+      normalizedCapacityFunctionofTemperatureCurve.setMinimumValueofy(24);
+      normalizedCapacityFunctionofTemperatureCurve.setMaximumValueofy(35);
+      normalizedCapacityFunctionofTemperatureCurve.setInputUnitTypeforX("Temperature");
+      normalizedCapacityFunctionofTemperatureCurve.setInputUnitTypeforY("Temperature");
+      ok = setNormalizedCapacityFunctionofTemperatureCurve(normalizedCapacityFunctionofTemperatureCurve);
+      OS_ASSERT(ok);
+    }
+
+    {
+      CurveBiquadratic fuelEnergyInputRatioFunctionofTemperatureCurve(model);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setName("GAHP Heating EIRFT");
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient1Constant(1);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient2x(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient3xPOW2(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient4y(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient5yPOW2(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setCoefficient6xTIMESY(0);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setMinimumValueofx(5);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setMaximumValueofx(10);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setMinimumValueofy(24);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setMaximumValueofy(35);
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setInputUnitTypeforX("Temperature");
+      fuelEnergyInputRatioFunctionofTemperatureCurve.setInputUnitTypeforY("Temperature");
+      ok = setFuelEnergyInputRatioFunctionofTemperatureCurve(fuelEnergyInputRatioFunctionofTemperatureCurve);
+      OS_ASSERT(ok);
+    }
+
+    {
+      CurveQuadratic fuelEnergyInputRatioFunctionofPLRCurve(model);
+      fuelEnergyInputRatioFunctionofPLRCurve.setName("GAHP Heating EIRFPLR");
+      fuelEnergyInputRatioFunctionofPLRCurve.setCoefficient1Constant(1);
+      fuelEnergyInputRatioFunctionofPLRCurve.setCoefficient2x(0);
+      fuelEnergyInputRatioFunctionofPLRCurve.setCoefficient3xPOW2(0);
+      fuelEnergyInputRatioFunctionofPLRCurve.setMinimumValueofx(0);
+      fuelEnergyInputRatioFunctionofPLRCurve.setMaximumValueofx(1);
+      ok = setFuelEnergyInputRatioFunctionofPLRCurve(fuelEnergyInputRatioFunctionofPLRCurve);
+      OS_ASSERT(ok);
+    }
+    ok = setMinimumPartLoadRatio(0.1);
+    OS_ASSERT(ok);
+    ok = setMaximumPartLoadRatio(1.0);
+    OS_ASSERT(ok);
+    ok = setDefrostControlType("Timed");
+    OS_ASSERT(ok);
+    ok = setDefrostOperationTimeFraction(0);
+    OS_ASSERT(ok);
+    ok = setResistiveDefrostHeaterCapacity(0);
+    OS_ASSERT(ok);
+    ok = setMaximumOutdoorDrybulbTemperatureforDefrostOperation(5);
+    OS_ASSERT(ok);
+    ok = setNominalAuxiliaryElectricPower(0);
+    OS_ASSERT(ok);
+    ok = setStandbyElectricPower(0);
+    OS_ASSERT(ok);
+  }
+
+  HeatPumpAirToWaterFuelFiredHeating::HeatPumpAirToWaterFuelFiredHeating(const Model& model,
+                                                                         const Curve& normalizedCapacityFunctionofTemperatureCurve,
+                                                                         const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve,
+                                                                         const Curve& fuelEnergyInputRatioFunctionofPLRCurve)
+    : StraightComponent(HeatPumpAirToWaterFuelFiredHeating::iddObjectType(), model) {
+    OS_ASSERT(getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>());
+
+    bool ok = true;
+    ok = setFuelType("NaturalGas");
+    OS_ASSERT(ok);
+    autosizeNominalHeatingCapacity();
+    ok = setNominalCOP(1.0);
+    OS_ASSERT(ok);
+    autosizeDesignFlowRate();
+    ok = setDesignSupplyTemperature(60);
+    OS_ASSERT(ok);
+    ok = setDesignTemperatureLift(11.1);
+    OS_ASSERT(ok);
+    ok = setSizingFactor(1.0);
+    OS_ASSERT(ok);
+    ok = setFlowMode("NotModulated");
+    OS_ASSERT(ok);
+    ok = setOutdoorAirTemperatureCurveInputVariable("DryBulb");
+    OS_ASSERT(ok);
+    ok = setWaterTemperatureCurveInputVariable("EnteringCondenser");
+    OS_ASSERT(ok);
+
+    ok = setNormalizedCapacityFunctionofTemperatureCurve(normalizedCapacityFunctionofTemperatureCurve);
+    if (!ok) {
+      remove();
+      LOG_AND_THROW("Unable to set " << briefDescription() << "'s normalized capacity modifier function of temperature curve to "
+                                     << normalizedCapacityFunctionofTemperatureCurve.briefDescription() << ".");
+    }
+
+    ok = setFuelEnergyInputRatioFunctionofTemperatureCurve(fuelEnergyInputRatioFunctionofTemperatureCurve);
+    if (!ok) {
+      remove();
+      LOG_AND_THROW("Unable to set " << briefDescription() << "'s fuel energy input ratio function of temperature curve to "
+                                     << fuelEnergyInputRatioFunctionofTemperatureCurve.briefDescription() << ".");
+    }
+
+    ok = setFuelEnergyInputRatioFunctionofPLRCurve(fuelEnergyInputRatioFunctionofPLRCurve);
+    if (!ok) {
+      remove();
+      LOG_AND_THROW("Unable to set " << briefDescription() << "'s fuel energy input ratio function of PLR curve to "
+                                     << fuelEnergyInputRatioFunctionofPLRCurve.briefDescription() << ".");
+    }
+
+    ok = setMinimumPartLoadRatio(0.1);
+    OS_ASSERT(ok);
+    ok = setMaximumPartLoadRatio(1.0);
+    OS_ASSERT(ok);
+    ok = setDefrostControlType("Timed");
+    OS_ASSERT(ok);
+    ok = setDefrostOperationTimeFraction(0);
+    OS_ASSERT(ok);
+    ok = setResistiveDefrostHeaterCapacity(0);
+    OS_ASSERT(ok);
+    ok = setMaximumOutdoorDrybulbTemperatureforDefrostOperation(5);
+    OS_ASSERT(ok);
+    ok = setNominalAuxiliaryElectricPower(0);
+    OS_ASSERT(ok);
+    ok = setStandbyElectricPower(0);
+    OS_ASSERT(ok);
+  }
+
+  IddObjectType HeatPumpAirToWaterFuelFiredHeating::iddObjectType() {
+    return {IddObjectType::OS_HeatPump_AirToWater_FuelFired_Heating};
+  }
+
+  std::vector<std::string> HeatPumpAirToWaterFuelFiredHeating::fuelTypeValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_HeatPump_AirToWater_FuelFired_HeatingFields::FuelType);
+  }
+
+  std::vector<std::string> HeatPumpAirToWaterFuelFiredHeating::flowModeValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_HeatPump_AirToWater_FuelFired_HeatingFields::FlowMode);
+  }
+
+  std::vector<std::string> HeatPumpAirToWaterFuelFiredHeating::outdoorAirTemperatureCurveInputVariableValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
+                          OS_HeatPump_AirToWater_FuelFired_HeatingFields::OutdoorAirTemperatureCurveInputVariable);
+  }
+
+  std::vector<std::string> HeatPumpAirToWaterFuelFiredHeating::waterTemperatureCurveInputVariableValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
+                          OS_HeatPump_AirToWater_FuelFired_HeatingFields::WaterTemperatureCurveInputVariable);
+  }
+
+  std::vector<std::string> HeatPumpAirToWaterFuelFiredHeating::defrostControlTypeValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
+                          OS_HeatPump_AirToWater_FuelFired_HeatingFields::DefrostControlType);
+  }
+
+  boost::optional<HeatPumpAirToWaterFuelFiredCooling> HeatPumpAirToWaterFuelFiredHeating::companionCoolingHeatPump() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->companionCoolingHeatPump();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredHeating::fuelType() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->fuelType();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredHeating::endUseSubcategory() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->endUseSubcategory();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::isEndUseSubcategoryDefaulted() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->isEndUseSubcategoryDefaulted();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredHeating::nominalHeatingCapacity() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->nominalHeatingCapacity();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::isNominalHeatingCapacityAutosized() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->isNominalHeatingCapacityAutosized();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredHeating::autosizedNominalHeatingCapacity() {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->autosizedNominalHeatingCapacity();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::nominalCOP() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->nominalCOP();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredHeating::designFlowRate() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->designFlowRate();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::isDesignFlowRateAutosized() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->isDesignFlowRateAutosized();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredHeating::autosizedDesignFlowRate() {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->autosizedDesignFlowRate();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::designSupplyTemperature() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->designSupplyTemperature();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredHeating::designTemperatureLift() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->designTemperatureLift();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::isDesignTemperatureLiftAutosized() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->isDesignTemperatureLiftAutosized();
+  }
+
+  boost::optional<double> HeatPumpAirToWaterFuelFiredHeating::autosizedDesignTemperatureLift() {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->autosizedDesignTemperatureLift();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::sizingFactor() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->sizingFactor();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredHeating::flowMode() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->flowMode();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredHeating::outdoorAirTemperatureCurveInputVariable() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->outdoorAirTemperatureCurveInputVariable();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredHeating::waterTemperatureCurveInputVariable() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->waterTemperatureCurveInputVariable();
+  }
+
+  Curve HeatPumpAirToWaterFuelFiredHeating::normalizedCapacityFunctionofTemperatureCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->normalizedCapacityFunctionofTemperatureCurve();
+  }
+
+  Curve HeatPumpAirToWaterFuelFiredHeating::fuelEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->fuelEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  Curve HeatPumpAirToWaterFuelFiredHeating::fuelEnergyInputRatioFunctionofPLRCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->fuelEnergyInputRatioFunctionofPLRCurve();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::minimumPartLoadRatio() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->minimumPartLoadRatio();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::maximumPartLoadRatio() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->maximumPartLoadRatio();
+  }
+
+  std::string HeatPumpAirToWaterFuelFiredHeating::defrostControlType() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->defrostControlType();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::defrostOperationTimeFraction() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->defrostOperationTimeFraction();
+  }
+
+  boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating::fuelEnergyInputRatioDefrostAdjustmentCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->fuelEnergyInputRatioDefrostAdjustmentCurve();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::resistiveDefrostHeaterCapacity() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->resistiveDefrostHeaterCapacity();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::maximumOutdoorDrybulbTemperatureforDefrostOperation() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->maximumOutdoorDrybulbTemperatureforDefrostOperation();
+  }
+
+  boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating::cyclingRatioFactorCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->cyclingRatioFactorCurve();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::nominalAuxiliaryElectricPower() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->nominalAuxiliaryElectricPower();
+  }
+
+  boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating::auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> HeatPumpAirToWaterFuelFiredHeating::auxiliaryElectricEnergyInputRatioFunctionofPLRCurve() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->auxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+  }
+
+  double HeatPumpAirToWaterFuelFiredHeating::standbyElectricPower() const {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->standbyElectricPower();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setCompanionCoolingHeatPump(const HeatPumpAirToWaterFuelFiredCooling& heatPumpAirToWaterFuelFiredCooling) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setCompanionCoolingHeatPump(heatPumpAirToWaterFuelFiredCooling);
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::resetCompanionCoolingHeatPump() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->resetCompanionCoolingHeatPump();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setFuelType(const std::string& fuelType) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setFuelType(fuelType);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setEndUseSubcategory(const std::string& endUseSubcategory) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setEndUseSubcategory(endUseSubcategory);
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::resetEndUseSubcategory() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->resetEndUseSubcategory();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setNominalHeatingCapacity(double nominalHeatingCapacity) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setNominalHeatingCapacity(nominalHeatingCapacity);
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::resetNominalHeatingCapacity() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->resetNominalHeatingCapacity();
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::autosizeNominalHeatingCapacity() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->autosizeNominalHeatingCapacity();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setNominalCOP(double nominalCOP) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setNominalCOP(nominalCOP);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setDesignFlowRate(double designFlowRate) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setDesignFlowRate(designFlowRate);
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::resetDesignFlowRate() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->resetDesignFlowRate();
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::autosizeDesignFlowRate() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->autosizeDesignFlowRate();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setDesignSupplyTemperature(double designSupplyTemperature) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setDesignSupplyTemperature(designSupplyTemperature);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setDesignTemperatureLift(double designTemperatureLift) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setDesignTemperatureLift(designTemperatureLift);
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::autosizeDesignTemperatureLift() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->autosizeDesignTemperatureLift();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setSizingFactor(double sizingFactor) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setSizingFactor(sizingFactor);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setFlowMode(const std::string& flowMode) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setFlowMode(flowMode);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setOutdoorAirTemperatureCurveInputVariable(const std::string& outdoorAirTemperatureCurveInputVariable) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setOutdoorAirTemperatureCurveInputVariable(
+      outdoorAirTemperatureCurveInputVariable);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setWaterTemperatureCurveInputVariable(const std::string& waterTemperatureCurveInputVariable) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setWaterTemperatureCurveInputVariable(waterTemperatureCurveInputVariable);
+  }
+
+  bool
+    HeatPumpAirToWaterFuelFiredHeating::setNormalizedCapacityFunctionofTemperatureCurve(const Curve& normalizedCapacityFunctionofTemperatureCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setNormalizedCapacityFunctionofTemperatureCurve(
+      normalizedCapacityFunctionofTemperatureCurve);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setFuelEnergyInputRatioFunctionofTemperatureCurve(
+    const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setFuelEnergyInputRatioFunctionofTemperatureCurve(
+      fuelEnergyInputRatioFunctionofTemperatureCurve);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setFuelEnergyInputRatioFunctionofPLRCurve(const Curve& fuelEnergyInputRatioFunctionofPLRCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setFuelEnergyInputRatioFunctionofPLRCurve(
+      fuelEnergyInputRatioFunctionofPLRCurve);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setMinimumPartLoadRatio(double minimumPartLoadRatio) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setMinimumPartLoadRatio(minimumPartLoadRatio);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setMaximumPartLoadRatio(double maximumPartLoadRatio) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setMaximumPartLoadRatio(maximumPartLoadRatio);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setDefrostControlType(const std::string& defrostControlType) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setDefrostControlType(defrostControlType);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setDefrostOperationTimeFraction(double defrostOperationTimeFraction) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setDefrostOperationTimeFraction(defrostOperationTimeFraction);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setFuelEnergyInputRatioDefrostAdjustmentCurve(const Curve& fuelEnergyInputRatioDefrostAdjustmentCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setFuelEnergyInputRatioDefrostAdjustmentCurve(
+      fuelEnergyInputRatioDefrostAdjustmentCurve);
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::resetFuelEnergyInputRatioDefrostAdjustmentCurve() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->resetFuelEnergyInputRatioDefrostAdjustmentCurve();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setResistiveDefrostHeaterCapacity(double resistiveDefrostHeaterCapacity) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setResistiveDefrostHeaterCapacity(resistiveDefrostHeaterCapacity);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setMaximumOutdoorDrybulbTemperatureforDefrostOperation(
+    double maximumOutdoorDrybulbTemperatureforDefrostOperation) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setMaximumOutdoorDrybulbTemperatureforDefrostOperation(
+      maximumOutdoorDrybulbTemperatureforDefrostOperation);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setCyclingRatioFactorCurve(const Curve& cyclingRatioFactorCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setCyclingRatioFactorCurve(cyclingRatioFactorCurve);
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::resetCyclingRatioFactorCurve() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->resetCyclingRatioFactorCurve();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setNominalAuxiliaryElectricPower(double nominalAuxiliaryElectricPower) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setNominalAuxiliaryElectricPower(nominalAuxiliaryElectricPower);
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(
+    const Curve& auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(
+      auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve);
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(
+    const Curve& auxiliaryElectricEnergyInputRatioFunctionofPLRCurve) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(
+      auxiliaryElectricEnergyInputRatioFunctionofPLRCurve);
+  }
+
+  void HeatPumpAirToWaterFuelFiredHeating::resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve() {
+    getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+  }
+
+  bool HeatPumpAirToWaterFuelFiredHeating::setStandbyElectricPower(double standbyElectricPower) {
+    return getImpl<detail::HeatPumpAirToWaterFuelFiredHeating_Impl>()->setStandbyElectricPower(standbyElectricPower);
+  }
+
+  /// @cond
+  HeatPumpAirToWaterFuelFiredHeating::HeatPumpAirToWaterFuelFiredHeating(std::shared_ptr<detail::HeatPumpAirToWaterFuelFiredHeating_Impl> impl)
+    : StraightComponent(std::move(impl)) {}
+  /// @endcond
+
+}  // namespace model
+}  // namespace openstudio
diff --git a/src/model/HeatPumpAirToWaterFuelFiredHeating.hpp b/src/model/HeatPumpAirToWaterFuelFiredHeating.hpp
new file mode 100644
index 00000000000..919e51e5285
--- /dev/null
+++ b/src/model/HeatPumpAirToWaterFuelFiredHeating.hpp
@@ -0,0 +1,270 @@
+/***********************************************************************************************************************
+*  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.
+***********************************************************************************************************************/
+
+#ifndef MODEL_HEATPUMPAIRTOWATERFUELFIREDHEATING_HPP
+#define MODEL_HEATPUMPAIRTOWATERFUELFIREDHEATING_HPP
+
+#include <model/ModelAPI.hpp>
+#include "StraightComponent.hpp"
+
+namespace openstudio {
+
+namespace model {
+
+  class HeatPumpAirToWaterFuelFiredCooling;
+  class Curve;
+  // class OutdoorAirNode;
+
+  namespace detail {
+
+    class HeatPumpAirToWaterFuelFiredHeating_Impl;
+
+  }  // namespace detail
+
+  /** HeatPumpAirToWaterFuelFiredHeating is a StraightComponent that wraps the OpenStudio IDD object 'OS:HeatPump:AirToWater:FuelFired:Heating'. */
+  class MODEL_API HeatPumpAirToWaterFuelFiredHeating : public StraightComponent
+  {
+   public:
+    /** @name Constructors and Destructors */
+    //@{
+
+    explicit HeatPumpAirToWaterFuelFiredHeating(const Model& model);
+
+    explicit HeatPumpAirToWaterFuelFiredHeating(const Model& model, const Curve& normalizedCapacityFunctionofTemperatureCurve,
+                                                const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve,
+                                                const Curve& fuelEnergyInputRatioFunctionofPLRCurve);
+
+    virtual ~HeatPumpAirToWaterFuelFiredHeating() = default;
+    // Default the copy and move operators because the virtual dtor is explicit
+    HeatPumpAirToWaterFuelFiredHeating(const HeatPumpAirToWaterFuelFiredHeating& other) = default;
+    HeatPumpAirToWaterFuelFiredHeating(HeatPumpAirToWaterFuelFiredHeating&& other) = default;
+    HeatPumpAirToWaterFuelFiredHeating& operator=(const HeatPumpAirToWaterFuelFiredHeating&) = default;
+    HeatPumpAirToWaterFuelFiredHeating& operator=(HeatPumpAirToWaterFuelFiredHeating&&) = default;
+
+    //@}
+
+    static IddObjectType iddObjectType();
+
+    static std::vector<std::string> fuelTypeValues();
+
+    static std::vector<std::string> flowModeValues();
+
+    static std::vector<std::string> outdoorAirTemperatureCurveInputVariableValues();
+
+    static std::vector<std::string> waterTemperatureCurveInputVariableValues();
+
+    static std::vector<std::string> defrostControlTypeValues();
+
+    /** @name Getters */
+    //@{
+
+    // boost::optional<OutdoorAirNode> airSourceNode() const;
+
+    boost::optional<HeatPumpAirToWaterFuelFiredCooling> companionCoolingHeatPump() const;
+
+    std::string fuelType() const;
+
+    std::string endUseSubcategory() const;
+
+    bool isEndUseSubcategoryDefaulted() const;
+
+    boost::optional<double> nominalHeatingCapacity() const;
+
+    bool isNominalHeatingCapacityAutosized() const;
+
+    boost::optional<double> autosizedNominalHeatingCapacity();
+
+    double nominalCOP() const;
+
+    boost::optional<double> designFlowRate() const;
+
+    bool isDesignFlowRateAutosized() const;
+
+    boost::optional<double> autosizedDesignFlowRate();
+
+    double designSupplyTemperature() const;
+
+    boost::optional<double> designTemperatureLift() const;
+
+    bool isDesignTemperatureLiftAutosized() const;
+
+    boost::optional<double> autosizedDesignTemperatureLift();
+
+    double sizingFactor() const;
+
+    std::string flowMode() const;
+
+    std::string outdoorAirTemperatureCurveInputVariable() const;
+
+    std::string waterTemperatureCurveInputVariable() const;
+
+    Curve normalizedCapacityFunctionofTemperatureCurve() const;
+
+    Curve fuelEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    Curve fuelEnergyInputRatioFunctionofPLRCurve() const;
+
+    double minimumPartLoadRatio() const;
+
+    double maximumPartLoadRatio() const;
+
+    std::string defrostControlType() const;
+
+    double defrostOperationTimeFraction() const;
+
+    boost::optional<Curve> fuelEnergyInputRatioDefrostAdjustmentCurve() const;
+
+    double resistiveDefrostHeaterCapacity() const;
+
+    double maximumOutdoorDrybulbTemperatureforDefrostOperation() const;
+
+    boost::optional<Curve> cyclingRatioFactorCurve() const;
+
+    double nominalAuxiliaryElectricPower() const;
+
+    boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofPLRCurve() const;
+
+    double standbyElectricPower() const;
+
+    //@}
+    /** @name Setters */
+    //@{
+
+    // bool setAirSourceNode(const OutdoorAirNode& outdoorAirNode);
+
+    // void resetAirSourceNode();
+
+    bool setCompanionCoolingHeatPump(const HeatPumpAirToWaterFuelFiredCooling& heatPumpAirToWaterFuelFiredCooling);
+
+    void resetCompanionCoolingHeatPump();
+
+    bool setFuelType(const std::string& fuelType);
+
+    bool setEndUseSubcategory(const std::string& endUseSubcategory);
+
+    void resetEndUseSubcategory();
+
+    bool setNominalHeatingCapacity(double nominalHeatingCapacity);
+
+    void resetNominalHeatingCapacity();
+
+    void autosizeNominalHeatingCapacity();
+
+    bool setNominalCOP(double nominalCOP);
+
+    bool setDesignFlowRate(double designFlowRate);
+
+    void resetDesignFlowRate();
+
+    void autosizeDesignFlowRate();
+
+    bool setDesignSupplyTemperature(double designSupplyTemperature);
+
+    bool setDesignTemperatureLift(double designTemperatureLift);
+
+    void autosizeDesignTemperatureLift();
+
+    bool setSizingFactor(double sizingFactor);
+
+    bool setFlowMode(const std::string& flowMode);
+
+    bool setOutdoorAirTemperatureCurveInputVariable(const std::string& outdoorAirTemperatureCurveInputVariable);
+
+    bool setWaterTemperatureCurveInputVariable(const std::string& waterTemperatureCurveInputVariable);
+
+    bool setNormalizedCapacityFunctionofTemperatureCurve(const Curve& normalizedCapacityFunctionofTemperatureCurve);
+
+    bool setFuelEnergyInputRatioFunctionofTemperatureCurve(const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve);
+
+    bool setFuelEnergyInputRatioFunctionofPLRCurve(const Curve& fuelEnergyInputRatioFunctionofPLRCurve);
+
+    bool setMinimumPartLoadRatio(double minimumPartLoadRatio);
+
+    bool setMaximumPartLoadRatio(double maximumPartLoadRatio);
+
+    bool setDefrostControlType(const std::string& defrostControlType);
+
+    bool setDefrostOperationTimeFraction(double defrostOperationTimeFraction);
+
+    bool setFuelEnergyInputRatioDefrostAdjustmentCurve(const Curve& fuelEnergyInputRatioDefrostAdjustmentCurve);
+
+    void resetFuelEnergyInputRatioDefrostAdjustmentCurve();
+
+    bool setResistiveDefrostHeaterCapacity(double resistiveDefrostHeaterCapacity);
+
+    bool setMaximumOutdoorDrybulbTemperatureforDefrostOperation(double maximumOutdoorDrybulbTemperatureforDefrostOperation);
+
+    bool setCyclingRatioFactorCurve(const Curve& cyclingRatioFactorCurve);
+
+    void resetCyclingRatioFactorCurve();
+
+    bool setNominalAuxiliaryElectricPower(double nominalAuxiliaryElectricPower);
+
+    bool setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(const Curve& auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve);
+
+    void resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+
+    bool setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(const Curve& auxiliaryElectricEnergyInputRatioFunctionofPLRCurve);
+
+    void resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+
+    bool setStandbyElectricPower(double standbyElectricPower);
+
+    //@}
+    /** @name Other */
+    //@{
+
+    //@}
+   protected:
+    /// @cond
+    using ImplType = detail::HeatPumpAirToWaterFuelFiredHeating_Impl;
+
+    explicit HeatPumpAirToWaterFuelFiredHeating(std::shared_ptr<detail::HeatPumpAirToWaterFuelFiredHeating_Impl> impl);
+
+    friend class detail::HeatPumpAirToWaterFuelFiredHeating_Impl;
+    friend class Model;
+    friend class IdfObject;
+    friend class openstudio::detail::IdfObject_Impl;
+    /// @endcond
+   private:
+    REGISTER_LOGGER("openstudio.model.HeatPumpAirToWaterFuelFiredHeating");
+  };
+
+  /** \relates HeatPumpAirToWaterFuelFiredHeating*/
+  using OptionalHeatPumpAirToWaterFuelFiredHeating = boost::optional<HeatPumpAirToWaterFuelFiredHeating>;
+
+  /** \relates HeatPumpAirToWaterFuelFiredHeating*/
+  using HeatPumpAirToWaterFuelFiredHeatingVector = std::vector<HeatPumpAirToWaterFuelFiredHeating>;
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_HEATPUMPAIRTOWATERFUELFIREDHEATING_HPP
diff --git a/src/model/HeatPumpAirToWaterFuelFiredHeating_Impl.hpp b/src/model/HeatPumpAirToWaterFuelFiredHeating_Impl.hpp
new file mode 100644
index 00000000000..1099d334c50
--- /dev/null
+++ b/src/model/HeatPumpAirToWaterFuelFiredHeating_Impl.hpp
@@ -0,0 +1,258 @@
+/***********************************************************************************************************************
+*  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.
+***********************************************************************************************************************/
+
+#ifndef MODEL_HEATPUMPAIRTOWATERFUELFIREDHEATING_IMPL_HPP
+#define MODEL_HEATPUMPAIRTOWATERFUELFIREDHEATING_IMPL_HPP
+
+#include <model/ModelAPI.hpp>
+#include "StraightComponent_Impl.hpp"
+
+namespace openstudio {
+namespace model {
+
+  class HeatPumpAirToWaterFuelFiredCooling;
+  class Curve;
+  // class OutdoorAirNode;
+
+  namespace detail {
+
+    /** HeatPumpAirToWaterFuelFiredHeating_Impl is a StraightComponent_Impl that is the implementation class for HeatPumpAirToWaterFuelFiredHeating.*/
+    class MODEL_API HeatPumpAirToWaterFuelFiredHeating_Impl : public StraightComponent_Impl
+    {
+     public:
+      /** @name Constructors and Destructors */
+      //@{
+
+      HeatPumpAirToWaterFuelFiredHeating_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle);
+
+      HeatPumpAirToWaterFuelFiredHeating_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle);
+
+      HeatPumpAirToWaterFuelFiredHeating_Impl(const HeatPumpAirToWaterFuelFiredHeating_Impl& other, Model_Impl* model, bool keepHandle);
+
+      virtual ~HeatPumpAirToWaterFuelFiredHeating_Impl() {}
+
+      //@}
+      /** @name Virtual Methods */
+      //@{
+
+      virtual const std::vector<std::string>& outputVariableNames() const override;
+
+      virtual IddObjectType iddObjectType() const override;
+
+      virtual unsigned inletPort() const override;
+
+      virtual unsigned outletPort() const override;
+
+      virtual void autosize() override;
+
+      virtual void applySizingValues() override;
+
+      virtual bool addToNode(Node& node) override;
+
+      // Resets the Companion Heat Pump
+      virtual ModelObject clone(Model model) const override;
+
+      //@}
+      /** @name Getters */
+      //@{
+
+      // boost::optional<OutdoorAirNode> airSourceNode() const;
+
+      boost::optional<HeatPumpAirToWaterFuelFiredCooling> companionCoolingHeatPump() const;
+
+      std::string fuelType() const;
+
+      std::string endUseSubcategory() const;
+
+      bool isEndUseSubcategoryDefaulted() const;
+
+      boost::optional<double> nominalHeatingCapacity() const;
+
+      bool isNominalHeatingCapacityAutosized() const;
+
+      boost::optional<double> autosizedNominalHeatingCapacity();
+
+      double nominalCOP() const;
+
+      boost::optional<double> designFlowRate() const;
+
+      bool isDesignFlowRateAutosized() const;
+
+      boost::optional<double> autosizedDesignFlowRate();
+
+      double designSupplyTemperature() const;
+
+      boost::optional<double> designTemperatureLift() const;
+
+      bool isDesignTemperatureLiftAutosized() const;
+
+      boost::optional<double> autosizedDesignTemperatureLift();
+
+      double sizingFactor() const;
+
+      std::string flowMode() const;
+
+      std::string outdoorAirTemperatureCurveInputVariable() const;
+
+      std::string waterTemperatureCurveInputVariable() const;
+
+      Curve normalizedCapacityFunctionofTemperatureCurve() const;
+
+      Curve fuelEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      Curve fuelEnergyInputRatioFunctionofPLRCurve() const;
+
+      double minimumPartLoadRatio() const;
+
+      double maximumPartLoadRatio() const;
+
+      std::string defrostControlType() const;
+
+      double defrostOperationTimeFraction() const;
+
+      boost::optional<Curve> fuelEnergyInputRatioDefrostAdjustmentCurve() const;
+
+      double resistiveDefrostHeaterCapacity() const;
+
+      double maximumOutdoorDrybulbTemperatureforDefrostOperation() const;
+
+      boost::optional<Curve> cyclingRatioFactorCurve() const;
+
+      double nominalAuxiliaryElectricPower() const;
+
+      boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> auxiliaryElectricEnergyInputRatioFunctionofPLRCurve() const;
+
+      double standbyElectricPower() const;
+
+      //@}
+      /** @name Setters */
+      //@{
+
+      // bool setAirSourceNode(const OutdoorAirNode& outdoorAirNode);
+
+      // void resetAirSourceNode();
+
+      bool setCompanionCoolingHeatPump(const HeatPumpAirToWaterFuelFiredCooling& heatPumpAirToWaterFuelFiredCooling);
+
+      void resetCompanionCoolingHeatPump();
+
+      bool setFuelType(const std::string& fuelType);
+
+      bool setEndUseSubcategory(const std::string& endUseSubcategory);
+
+      void resetEndUseSubcategory();
+
+      bool setNominalHeatingCapacity(double nominalHeatingCapacity);
+
+      void resetNominalHeatingCapacity();
+
+      void autosizeNominalHeatingCapacity();
+
+      bool setNominalCOP(double nominalCOP);
+
+      bool setDesignFlowRate(double designFlowRate);
+
+      void resetDesignFlowRate();
+
+      void autosizeDesignFlowRate();
+
+      bool setDesignSupplyTemperature(double designSupplyTemperature);
+
+      bool setDesignTemperatureLift(double designTemperatureLift);
+
+      void autosizeDesignTemperatureLift();
+
+      bool setSizingFactor(double sizingFactor);
+
+      bool setFlowMode(const std::string& flowMode);
+
+      bool setOutdoorAirTemperatureCurveInputVariable(const std::string& outdoorAirTemperatureCurveInputVariable);
+
+      bool setWaterTemperatureCurveInputVariable(const std::string& waterTemperatureCurveInputVariable);
+
+      bool setNormalizedCapacityFunctionofTemperatureCurve(const Curve& normalizedCapacityFunctionofTemperatureCurve);
+
+      bool setFuelEnergyInputRatioFunctionofTemperatureCurve(const Curve& fuelEnergyInputRatioFunctionofTemperatureCurve);
+
+      bool setFuelEnergyInputRatioFunctionofPLRCurve(const Curve& fuelEnergyInputRatioFunctionofPLRCurve);
+
+      bool setMinimumPartLoadRatio(double minimumPartLoadRatio);
+
+      bool setMaximumPartLoadRatio(double maximumPartLoadRatio);
+
+      bool setDefrostControlType(const std::string& defrostControlType);
+
+      bool setDefrostOperationTimeFraction(double defrostOperationTimeFraction);
+
+      bool setFuelEnergyInputRatioDefrostAdjustmentCurve(const Curve& fuelEnergyInputRatioDefrostAdjustmentCurve);
+
+      void resetFuelEnergyInputRatioDefrostAdjustmentCurve();
+
+      bool setResistiveDefrostHeaterCapacity(double resistiveDefrostHeaterCapacity);
+
+      bool setMaximumOutdoorDrybulbTemperatureforDefrostOperation(double maximumOutdoorDrybulbTemperatureforDefrostOperation);
+
+      bool setCyclingRatioFactorCurve(const Curve& cyclingRatioFactorCurve);
+
+      void resetCyclingRatioFactorCurve();
+
+      bool setNominalAuxiliaryElectricPower(double nominalAuxiliaryElectricPower);
+
+      bool setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(const Curve& auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve);
+
+      void resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+
+      bool setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(const Curve& auxiliaryElectricEnergyInputRatioFunctionofPLRCurve);
+
+      void resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+
+      bool setStandbyElectricPower(double standbyElectricPower);
+
+      //@}
+      /** @name Other */
+      //@{
+
+      //@}
+     protected:
+     private:
+      REGISTER_LOGGER("openstudio.model.HeatPumpAirToWaterFuelFiredHeating");
+
+      boost::optional<Curve> optionalNormalizedCapacityFunctionofTemperatureCurve() const;
+      boost::optional<Curve> optionalFuelEnergyInputRatioFunctionofTemperatureCurve() const;
+      boost::optional<Curve> optionalFuelEnergyInputRatioFunctionofPLRCurve() const;
+    };
+
+  }  // namespace detail
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_HEATPUMPAIRTOWATERFUELFIREDHEATING_IMPL_HPP
diff --git a/src/model/Model.cpp b/src/model/Model.cpp
index 680a79d638c..27bc20253e8 100644
--- a/src/model/Model.cpp
+++ b/src/model/Model.cpp
@@ -4137,6 +4137,8 @@ namespace model {
     REGISTER_CONSTRUCTOR(HeatExchangerDesiccantBalancedFlow);
     REGISTER_CONSTRUCTOR(HeatExchangerDesiccantBalancedFlowPerformanceDataType1);
     REGISTER_CONSTRUCTOR(HeatExchangerFluidToFluid);
+    REGISTER_CONSTRUCTOR(HeatPumpAirToWaterFuelFiredHeating);
+    REGISTER_CONSTRUCTOR(HeatPumpAirToWaterFuelFiredCooling);
     REGISTER_CONSTRUCTOR(HeatPumpWaterToWaterEquationFitCooling);
     REGISTER_CONSTRUCTOR(HeatPumpWaterToWaterEquationFitHeating);
     REGISTER_CONSTRUCTOR(HeatPumpPlantLoopEIRCooling);
@@ -4706,6 +4708,8 @@ namespace model {
     REGISTER_COPYCONSTRUCTORS(HeatExchangerDesiccantBalancedFlow);
     REGISTER_COPYCONSTRUCTORS(HeatExchangerDesiccantBalancedFlowPerformanceDataType1);
     REGISTER_COPYCONSTRUCTORS(HeatExchangerFluidToFluid);
+    REGISTER_COPYCONSTRUCTORS(HeatPumpAirToWaterFuelFiredHeating);
+    REGISTER_COPYCONSTRUCTORS(HeatPumpAirToWaterFuelFiredCooling);
     REGISTER_COPYCONSTRUCTORS(HeatPumpWaterToWaterEquationFitCooling);
     REGISTER_COPYCONSTRUCTORS(HeatPumpWaterToWaterEquationFitHeating);
     REGISTER_COPYCONSTRUCTORS(HeatPumpPlantLoopEIRCooling);
diff --git a/src/model/ModelStraightComponent.i b/src/model/ModelStraightComponent.i
index 70d6b683294..88a9e3ba1a9 100644
--- a/src/model/ModelStraightComponent.i
+++ b/src/model/ModelStraightComponent.i
@@ -165,6 +165,8 @@ MODELOBJECT_TEMPLATES(GroundHeatExchangerHorizontalTrench);
 MODELOBJECT_TEMPLATES(GroundHeatExchangerVertical);
 MODELOBJECT_TEMPLATES(HeaderedPumpsConstantSpeed);
 MODELOBJECT_TEMPLATES(HeaderedPumpsVariableSpeed);
+MODELOBJECT_TEMPLATES(HeatPumpAirToWaterFuelFiredHeating);
+MODELOBJECT_TEMPLATES(HeatPumpAirToWaterFuelFiredCooling);
 MODELOBJECT_TEMPLATES(HumidifierSteamElectric);
 MODELOBJECT_TEMPLATES(HumidifierSteamGas);
 MODELOBJECT_TEMPLATES(LoadProfilePlant);
@@ -248,6 +250,8 @@ SWIG_MODELOBJECT(GroundHeatExchangerHorizontalTrench,1);
 SWIG_MODELOBJECT(GroundHeatExchangerVertical,1);
 SWIG_MODELOBJECT(HeaderedPumpsConstantSpeed,1);
 SWIG_MODELOBJECT(HeaderedPumpsVariableSpeed,1);
+SWIG_MODELOBJECT(HeatPumpAirToWaterFuelFiredHeating,1);
+SWIG_MODELOBJECT(HeatPumpAirToWaterFuelFiredCooling,1);
 SWIG_MODELOBJECT(HumidifierSteamElectric,1);
 SWIG_MODELOBJECT(HumidifierSteamGas,1);
 SWIG_MODELOBJECT(LoadProfilePlant,1);


Test patch:
diff --git a/src/model/test/HeatPumpAirToWaterFuelFiredCooling_GTest.cpp b/src/model/test/HeatPumpAirToWaterFuelFiredCooling_GTest.cpp
new file mode 100644
index 00000000000..21b25e288c3
--- /dev/null
+++ b/src/model/test/HeatPumpAirToWaterFuelFiredCooling_GTest.cpp
@@ -0,0 +1,299 @@
+/***********************************************************************************************************************
+*  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 "ModelFixture.hpp"
+
+#include "../HeatPumpAirToWaterFuelFiredCooling.hpp"
+#include "../HeatPumpAirToWaterFuelFiredCooling_Impl.hpp"
+
+#include "../Model.hpp"
+#include "../Model_Impl.hpp"
+
+#include "../HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "../HeatPumpAirToWaterFuelFiredHeating_Impl.hpp"
+
+#include "../Curve.hpp"
+#include "../Curve_Impl.hpp"
+#include "../CurveBiquadratic.hpp"
+#include "../CurveBiquadratic_Impl.hpp"
+#include "../CurveQuadratic.hpp"
+#include "../CurveQuadratic_Impl.hpp"
+#include "../Node.hpp"
+#include "../Node_Impl.hpp"
+#include "../AirLoopHVAC.hpp"
+#include "../AirLoopHVAC_Impl.hpp"
+#include "../AirLoopHVACZoneSplitter.hpp"
+#include "../AirLoopHVACZoneSplitter_Impl.hpp"
+#include "../PlantLoop.hpp"
+#include "../PlantLoop_Impl.hpp"
+
+using namespace openstudio;
+using namespace openstudio::model;
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredCooling_HeatPumpAirToWaterFuelFiredCooling) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+
+  ASSERT_EXIT(
+    {
+      Model m;
+      HeatPumpAirToWaterFuelFiredCooling hp(m);
+
+      exit(0);
+    },
+    ::testing::ExitedWithCode(0), "");
+
+  Model m;
+  HeatPumpAirToWaterFuelFiredCooling hp(m);
+
+  EXPECT_FALSE(hp.companionHeatingHeatPump());
+  EXPECT_EQ("NaturalGas", hp.fuelType());
+  EXPECT_EQ("General", hp.endUseSubcategory());
+  EXPECT_TRUE(hp.isEndUseSubcategoryDefaulted());
+  EXPECT_FALSE(hp.nominalCoolingCapacity());
+  EXPECT_TRUE(hp.isNominalCoolingCapacityAutosized());
+  EXPECT_EQ(1.0, hp.nominalCOP());
+  EXPECT_FALSE(hp.designFlowRate());
+  EXPECT_TRUE(hp.isDesignFlowRateAutosized());
+  EXPECT_EQ(7.0, hp.designSupplyTemperature());
+  ASSERT_TRUE(hp.designTemperatureLift());
+  EXPECT_EQ(11.1, hp.designTemperatureLift().get());
+  EXPECT_FALSE(hp.isDesignTemperatureLiftAutosized());
+  EXPECT_EQ(1.0, hp.sizingFactor());
+  EXPECT_EQ("NotModulated", hp.flowMode());
+  EXPECT_EQ("DryBulb", hp.outdoorAirTemperatureCurveInputVariable());
+  EXPECT_EQ("EnteringEvaporator", hp.waterTemperatureCurveInputVariable());
+  boost::optional<Curve> normalizedCapacityFunctionofTemperatureCurve = hp.normalizedCapacityFunctionofTemperatureCurve();
+  EXPECT_TRUE(normalizedCapacityFunctionofTemperatureCurve);
+  boost::optional<Curve> fuelEnergyInputRatioFunctionofTemperatureCurve = hp.fuelEnergyInputRatioFunctionofTemperatureCurve();
+  EXPECT_TRUE(fuelEnergyInputRatioFunctionofTemperatureCurve);
+  boost::optional<Curve> fuelEnergyInputRatioFunctionofPLRCurve = hp.fuelEnergyInputRatioFunctionofPLRCurve();
+  EXPECT_TRUE(fuelEnergyInputRatioFunctionofPLRCurve);
+  EXPECT_EQ(0.1, hp.minimumPartLoadRatio());
+  EXPECT_EQ(1.0, hp.maximumPartLoadRatio());
+  EXPECT_FALSE(hp.cyclingRatioFactorCurve());
+  EXPECT_EQ(0, hp.nominalAuxiliaryElectricPower());
+  EXPECT_FALSE(hp.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_FALSE(hp.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve());
+  EXPECT_EQ(0, hp.standbyElectricPower());
+}
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredCooling_GettersSetters) {
+  Model m;
+  HeatPumpAirToWaterFuelFiredCooling hp(m);
+
+  HeatPumpAirToWaterFuelFiredHeating companionHP(m);
+  EXPECT_TRUE(hp.setCompanionHeatingHeatPump(companionHP));
+  EXPECT_TRUE(hp.setFuelType("Propane"));
+  EXPECT_TRUE(hp.setEndUseSubcategory("AnyText"));
+  EXPECT_TRUE(hp.setNominalCoolingCapacity(1.0));
+  EXPECT_TRUE(hp.setNominalCOP(2.0));
+  EXPECT_TRUE(hp.setDesignFlowRate(3.0));
+  EXPECT_TRUE(hp.setDesignSupplyTemperature(4.0));
+  EXPECT_TRUE(hp.setDesignTemperatureLift(5.0));
+  EXPECT_TRUE(hp.setSizingFactor(6.0));
+  EXPECT_TRUE(hp.setFlowMode("ConstantFlow"));
+  EXPECT_TRUE(hp.setOutdoorAirTemperatureCurveInputVariable("WetBulb"));
+  EXPECT_TRUE(hp.setWaterTemperatureCurveInputVariable("LeavingEvaporator"));
+  CurveBiquadratic curve1(m);
+  EXPECT_TRUE(hp.setNormalizedCapacityFunctionofTemperatureCurve(curve1));
+  CurveBiquadratic curve2(m);
+  EXPECT_TRUE(hp.setFuelEnergyInputRatioFunctionofTemperatureCurve(curve2));
+  CurveQuadratic curve3(m);
+  EXPECT_TRUE(hp.setFuelEnergyInputRatioFunctionofPLRCurve(curve3));
+  EXPECT_TRUE(hp.setMinimumPartLoadRatio(0.5));
+  EXPECT_TRUE(hp.setMaximumPartLoadRatio(0.75));
+  CurveQuadratic curve4(m);
+  EXPECT_TRUE(hp.setCyclingRatioFactorCurve(curve4));
+  EXPECT_TRUE(hp.setNominalAuxiliaryElectricPower(12.0));
+  CurveBiquadratic curve5(m);
+  EXPECT_TRUE(hp.setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(curve5));
+  CurveQuadratic curve6(m);
+  EXPECT_TRUE(hp.setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(curve6));
+  EXPECT_TRUE(hp.setStandbyElectricPower(13.0));
+
+  ASSERT_TRUE(hp.companionHeatingHeatPump());
+  EXPECT_EQ(companionHP.handle(), hp.companionHeatingHeatPump().get().handle());
+  EXPECT_EQ("Propane", hp.fuelType());
+  EXPECT_EQ("AnyText", hp.endUseSubcategory());
+  EXPECT_FALSE(hp.isEndUseSubcategoryDefaulted());
+  ASSERT_TRUE(hp.nominalCoolingCapacity());
+  EXPECT_EQ(1.0, hp.nominalCoolingCapacity().get());
+  EXPECT_FALSE(hp.isNominalCoolingCapacityAutosized());
+  EXPECT_EQ(2.0, hp.nominalCOP());
+  ASSERT_TRUE(hp.designFlowRate());
+  EXPECT_EQ(3.0, hp.designFlowRate().get());
+  EXPECT_FALSE(hp.isDesignFlowRateAutosized());
+  EXPECT_EQ(4.0, hp.designSupplyTemperature());
+  ASSERT_TRUE(hp.designTemperatureLift());
+  EXPECT_EQ(5.0, hp.designTemperatureLift().get());
+  EXPECT_FALSE(hp.isDesignTemperatureLiftAutosized());
+  EXPECT_EQ(6.0, hp.sizingFactor());
+  EXPECT_EQ("ConstantFlow", hp.flowMode());
+  EXPECT_EQ("WetBulb", hp.outdoorAirTemperatureCurveInputVariable());
+  EXPECT_EQ("LeavingEvaporator", hp.waterTemperatureCurveInputVariable());
+  EXPECT_EQ(curve1.handle(), hp.normalizedCapacityFunctionofTemperatureCurve().handle());
+  EXPECT_EQ(curve2.handle(), hp.fuelEnergyInputRatioFunctionofTemperatureCurve().handle());
+  EXPECT_EQ(curve3.handle(), hp.fuelEnergyInputRatioFunctionofPLRCurve().handle());
+  EXPECT_EQ(0.5, hp.minimumPartLoadRatio());
+  EXPECT_EQ(0.75, hp.maximumPartLoadRatio());
+  ASSERT_TRUE(hp.cyclingRatioFactorCurve());
+  EXPECT_EQ(curve4.handle(), hp.cyclingRatioFactorCurve().get().handle());
+  EXPECT_EQ(12.0, hp.nominalAuxiliaryElectricPower());
+  ASSERT_TRUE(hp.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(curve5.handle(), hp.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve().get().handle());
+  ASSERT_TRUE(hp.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve());
+  EXPECT_EQ(curve6.handle(), hp.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve().get().handle());
+  EXPECT_EQ(13.0, hp.standbyElectricPower());
+
+  hp.autosizeNominalCoolingCapacity();
+  hp.autosizeDesignFlowRate();
+  hp.autosizeDesignTemperatureLift();
+
+  EXPECT_FALSE(hp.nominalCoolingCapacity());
+  EXPECT_TRUE(hp.isNominalCoolingCapacityAutosized());
+  EXPECT_FALSE(hp.designFlowRate());
+  EXPECT_TRUE(hp.isDesignFlowRateAutosized());
+  EXPECT_FALSE(hp.designTemperatureLift());
+  EXPECT_TRUE(hp.isDesignTemperatureLiftAutosized());
+
+  hp.resetCompanionHeatingHeatPump();
+  hp.resetEndUseSubcategory();
+  hp.resetNominalCoolingCapacity();
+  hp.resetDesignFlowRate();
+  hp.resetCyclingRatioFactorCurve();
+  hp.resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+  hp.resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+
+  EXPECT_FALSE(hp.companionHeatingHeatPump());
+  EXPECT_EQ("General", hp.endUseSubcategory());
+  EXPECT_TRUE(hp.isEndUseSubcategoryDefaulted());
+  EXPECT_FALSE(hp.nominalCoolingCapacity());
+  EXPECT_FALSE(hp.designFlowRate());
+  EXPECT_FALSE(hp.cyclingRatioFactorCurve());
+  EXPECT_FALSE(hp.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_FALSE(hp.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve());
+}
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredCooling_remove) {
+  Model m;
+  HeatPumpAirToWaterFuelFiredCooling hp(m);
+
+  HeatPumpAirToWaterFuelFiredHeating companionHP(m);
+  EXPECT_TRUE(hp.setCompanionHeatingHeatPump(companionHP));
+  EXPECT_TRUE(companionHP.setCompanionCoolingHeatPump(hp));
+
+  auto size = m.modelObjects().size();
+  EXPECT_FALSE(hp.remove().empty());
+  EXPECT_EQ(size - 1, m.modelObjects().size());
+  EXPECT_FALSE(companionHP.companionCoolingHeatPump());
+  EXPECT_EQ(0, m.getConcreteModelObjects<HeatPumpAirToWaterFuelFiredCooling>().size());
+  EXPECT_EQ(1, m.getConcreteModelObjects<HeatPumpAirToWaterFuelFiredHeating>().size());
+}
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredCooling_clone) {
+  Model m;
+  CurveBiquadratic curve1(m);
+  CurveBiquadratic curve2(m);
+  CurveQuadratic curve3(m);
+  HeatPumpAirToWaterFuelFiredCooling hp(m, curve1, curve2, curve3);
+  EXPECT_EQ(2u, m.getConcreteModelObjects<CurveBiquadratic>().size());
+  EXPECT_EQ(1u, m.getConcreteModelObjects<CurveQuadratic>().size());
+
+  HeatPumpAirToWaterFuelFiredHeating companionHP(m);
+  EXPECT_TRUE(hp.setCompanionHeatingHeatPump(companionHP));
+  EXPECT_TRUE(companionHP.setCompanionCoolingHeatPump(hp));
+
+  EXPECT_EQ(4u, m.getConcreteModelObjects<CurveBiquadratic>().size());
+  EXPECT_EQ(2u, m.getConcreteModelObjects<CurveQuadratic>().size());
+
+  PlantLoop p(m);
+  EXPECT_TRUE(p.addSupplyBranchForComponent(hp));
+  EXPECT_TRUE(hp.inletModelObject());
+  EXPECT_TRUE(hp.outletModelObject());
+  EXPECT_TRUE(hp.plantLoop());
+
+  {
+    Model m2;
+    auto hpClone = hp.clone(m2).cast<HeatPumpAirToWaterFuelFiredCooling>();
+    EXPECT_FALSE(hpClone.companionHeatingHeatPump());
+    EXPECT_FALSE(hpClone.inletModelObject());
+    EXPECT_FALSE(hpClone.outletModelObject());
+    EXPECT_FALSE(hpClone.plantLoop());
+    EXPECT_NE(curve1.handle(), hpClone.normalizedCapacityFunctionofTemperatureCurve().handle());
+    EXPECT_NE(curve2.handle(), hpClone.fuelEnergyInputRatioFunctionofTemperatureCurve().handle());
+    EXPECT_NE(curve3.handle(), hpClone.fuelEnergyInputRatioFunctionofPLRCurve().handle());
+    EXPECT_EQ(2u, m2.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(1u, m2.getConcreteModelObjects<CurveQuadratic>().size());
+  }
+
+  {
+    auto hpClone = hp.clone(m).cast<HeatPumpAirToWaterFuelFiredCooling>();
+    EXPECT_FALSE(hpClone.companionHeatingHeatPump());
+    EXPECT_FALSE(hpClone.inletModelObject());
+    EXPECT_FALSE(hpClone.outletModelObject());
+    EXPECT_FALSE(hpClone.plantLoop());
+    EXPECT_EQ(curve1.handle(), hpClone.normalizedCapacityFunctionofTemperatureCurve().handle());
+    EXPECT_EQ(curve2.handle(), hpClone.fuelEnergyInputRatioFunctionofTemperatureCurve().handle());
+    EXPECT_EQ(curve3.handle(), hpClone.fuelEnergyInputRatioFunctionofPLRCurve().handle());
+    EXPECT_EQ(4u, m.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(2u, m.getConcreteModelObjects<CurveQuadratic>().size());
+  }
+}
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredCooling_addToNode) {
+  Model m;
+  HeatPumpAirToWaterFuelFiredCooling hp(m);
+
+  AirLoopHVAC airLoop(m);
+
+  Node supplyOutletNode = airLoop.supplyOutletNode();
+
+  EXPECT_FALSE(hp.addToNode(supplyOutletNode));
+  EXPECT_EQ(2, airLoop.supplyComponents().size());
+
+  Node inletNode = airLoop.zoneSplitter().lastOutletModelObject()->cast<Node>();
+
+  EXPECT_FALSE(hp.addToNode(inletNode));
+  EXPECT_EQ(5, airLoop.demandComponents().size());
+
+  PlantLoop plantLoop(m);
+  supplyOutletNode = plantLoop.supplyOutletNode();
+  EXPECT_TRUE(hp.addToNode(supplyOutletNode));
+  EXPECT_EQ(7, plantLoop.supplyComponents().size());
+
+  Node demandOutletNode = plantLoop.demandOutletNode();
+  EXPECT_FALSE(hp.addToNode(demandOutletNode));
+  EXPECT_EQ(5, plantLoop.demandComponents().size());
+
+  auto hpClone = hp.clone(m).cast<HeatPumpAirToWaterFuelFiredCooling>();
+  supplyOutletNode = plantLoop.supplyOutletNode();
+
+  EXPECT_TRUE(hpClone.addToNode(supplyOutletNode));
+  EXPECT_EQ(9, plantLoop.supplyComponents().size());
+}
diff --git a/src/model/test/HeatPumpAirToWaterFuelFiredHeating_GTest.cpp b/src/model/test/HeatPumpAirToWaterFuelFiredHeating_GTest.cpp
new file mode 100644
index 00000000000..89ed5e61bff
--- /dev/null
+++ b/src/model/test/HeatPumpAirToWaterFuelFiredHeating_GTest.cpp
@@ -0,0 +1,317 @@
+/***********************************************************************************************************************
+*  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 "ModelFixture.hpp"
+
+#include "../HeatPumpAirToWaterFuelFiredHeating.hpp"
+#include "../HeatPumpAirToWaterFuelFiredHeating_Impl.hpp"
+
+#include "../Model.hpp"
+#include "../Model_Impl.hpp"
+
+#include "../HeatPumpAirToWaterFuelFiredCooling.hpp"
+#include "../HeatPumpAirToWaterFuelFiredCooling_Impl.hpp"
+
+#include "../Curve.hpp"
+#include "../Curve_Impl.hpp"
+#include "../CurveBiquadratic.hpp"
+#include "../CurveBiquadratic_Impl.hpp"
+#include "../CurveQuadratic.hpp"
+#include "../CurveQuadratic_Impl.hpp"
+#include "../Node.hpp"
+#include "../Node_Impl.hpp"
+#include "../AirLoopHVAC.hpp"
+#include "../AirLoopHVAC_Impl.hpp"
+#include "../AirLoopHVACZoneSplitter.hpp"
+#include "../AirLoopHVACZoneSplitter_Impl.hpp"
+#include "../PlantLoop.hpp"
+#include "../PlantLoop_Impl.hpp"
+
+using namespace openstudio;
+using namespace openstudio::model;
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredHeating_HeatPumpAirToWaterFuelFiredHeating) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+
+  ASSERT_EXIT(
+    {
+      Model m;
+      HeatPumpAirToWaterFuelFiredHeating hp(m);
+
+      exit(0);
+    },
+    ::testing::ExitedWithCode(0), "");
+
+  Model m;
+  HeatPumpAirToWaterFuelFiredHeating hp(m);
+
+  EXPECT_FALSE(hp.companionCoolingHeatPump());
+  EXPECT_EQ("NaturalGas", hp.fuelType());
+  EXPECT_EQ("General", hp.endUseSubcategory());
+  EXPECT_TRUE(hp.isEndUseSubcategoryDefaulted());
+  EXPECT_FALSE(hp.nominalHeatingCapacity());
+  EXPECT_TRUE(hp.isNominalHeatingCapacityAutosized());
+  EXPECT_EQ(1.0, hp.nominalCOP());
+  EXPECT_FALSE(hp.designFlowRate());
+  EXPECT_TRUE(hp.isDesignFlowRateAutosized());
+  EXPECT_EQ(60, hp.designSupplyTemperature());
+  ASSERT_TRUE(hp.designTemperatureLift());
+  EXPECT_EQ(11.1, hp.designTemperatureLift().get());
+  EXPECT_FALSE(hp.isDesignTemperatureLiftAutosized());
+  EXPECT_EQ(1.0, hp.sizingFactor());
+  EXPECT_EQ("NotModulated", hp.flowMode());
+  EXPECT_EQ("DryBulb", hp.outdoorAirTemperatureCurveInputVariable());
+  EXPECT_EQ("EnteringCondenser", hp.waterTemperatureCurveInputVariable());
+  boost::optional<Curve> normalizedCapacityFunctionofTemperatureCurve = hp.normalizedCapacityFunctionofTemperatureCurve();
+  EXPECT_TRUE(normalizedCapacityFunctionofTemperatureCurve);
+  boost::optional<Curve> fuelEnergyInputRatioFunctionofTemperatureCurve = hp.fuelEnergyInputRatioFunctionofTemperatureCurve();
+  EXPECT_TRUE(fuelEnergyInputRatioFunctionofTemperatureCurve);
+  boost::optional<Curve> fuelEnergyInputRatioFunctionofPLRCurve = hp.fuelEnergyInputRatioFunctionofPLRCurve();
+  EXPECT_TRUE(fuelEnergyInputRatioFunctionofPLRCurve);
+  EXPECT_EQ(0.1, hp.minimumPartLoadRatio());
+  EXPECT_EQ(1.0, hp.maximumPartLoadRatio());
+  EXPECT_EQ("Timed", hp.defrostControlType());
+  EXPECT_EQ(0, hp.defrostOperationTimeFraction());
+  EXPECT_FALSE(hp.fuelEnergyInputRatioDefrostAdjustmentCurve());
+  EXPECT_EQ(0, hp.resistiveDefrostHeaterCapacity());
+  EXPECT_EQ(5, hp.maximumOutdoorDrybulbTemperatureforDefrostOperation());
+  EXPECT_FALSE(hp.cyclingRatioFactorCurve());
+  EXPECT_EQ(0, hp.nominalAuxiliaryElectricPower());
+  EXPECT_FALSE(hp.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_FALSE(hp.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve());
+  EXPECT_EQ(0, hp.standbyElectricPower());
+}
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredHeating_GettersSetters) {
+  Model m;
+  HeatPumpAirToWaterFuelFiredHeating hp(m);
+
+  HeatPumpAirToWaterFuelFiredCooling companionHP(m);
+  EXPECT_TRUE(hp.setCompanionCoolingHeatPump(companionHP));
+  EXPECT_TRUE(hp.setFuelType("Propane"));
+  EXPECT_TRUE(hp.setEndUseSubcategory("AnyText"));
+  EXPECT_TRUE(hp.setNominalHeatingCapacity(1.0));
+  EXPECT_TRUE(hp.setNominalCOP(2.0));
+  EXPECT_TRUE(hp.setDesignFlowRate(3.0));
+  EXPECT_TRUE(hp.setDesignSupplyTemperature(4.0));
+  EXPECT_TRUE(hp.setDesignTemperatureLift(5.0));
+  EXPECT_TRUE(hp.setSizingFactor(6.0));
+  EXPECT_TRUE(hp.setFlowMode("ConstantFlow"));
+  EXPECT_TRUE(hp.setOutdoorAirTemperatureCurveInputVariable("WetBulb"));
+  EXPECT_TRUE(hp.setWaterTemperatureCurveInputVariable("LeavingCondenser"));
+  CurveBiquadratic curve1(m);
+  EXPECT_TRUE(hp.setNormalizedCapacityFunctionofTemperatureCurve(curve1));
+  CurveBiquadratic curve2(m);
+  EXPECT_TRUE(hp.setFuelEnergyInputRatioFunctionofTemperatureCurve(curve2));
+  CurveQuadratic curve3(m);
+  EXPECT_TRUE(hp.setFuelEnergyInputRatioFunctionofPLRCurve(curve3));
+  EXPECT_TRUE(hp.setMinimumPartLoadRatio(0.5));
+  EXPECT_TRUE(hp.setMaximumPartLoadRatio(0.75));
+  EXPECT_TRUE(hp.setDefrostControlType("OnDemand"));
+  EXPECT_TRUE(hp.setDefrostOperationTimeFraction(0.8));
+  CurveQuadratic curve4(m);
+  EXPECT_TRUE(hp.setFuelEnergyInputRatioDefrostAdjustmentCurve(curve4));
+  EXPECT_TRUE(hp.setResistiveDefrostHeaterCapacity(10.0));
+  EXPECT_TRUE(hp.setMaximumOutdoorDrybulbTemperatureforDefrostOperation(9.9));
+  CurveQuadratic curve5(m);
+  EXPECT_TRUE(hp.setCyclingRatioFactorCurve(curve5));
+  EXPECT_TRUE(hp.setNominalAuxiliaryElectricPower(12.0));
+  CurveBiquadratic curve6(m);
+  EXPECT_TRUE(hp.setAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve(curve6));
+  CurveQuadratic curve7(m);
+  EXPECT_TRUE(hp.setAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve(curve7));
+  EXPECT_TRUE(hp.setStandbyElectricPower(13.0));
+
+  ASSERT_TRUE(hp.companionCoolingHeatPump());
+  EXPECT_EQ(companionHP.handle(), hp.companionCoolingHeatPump().get().handle());
+  EXPECT_EQ("Propane", hp.fuelType());
+  EXPECT_EQ("AnyText", hp.endUseSubcategory());
+  EXPECT_FALSE(hp.isEndUseSubcategoryDefaulted());
+  ASSERT_TRUE(hp.nominalHeatingCapacity());
+  EXPECT_EQ(1.0, hp.nominalHeatingCapacity().get());
+  EXPECT_FALSE(hp.isNominalHeatingCapacityAutosized());
+  EXPECT_EQ(2.0, hp.nominalCOP());
+  ASSERT_TRUE(hp.designFlowRate());
+  EXPECT_EQ(3.0, hp.designFlowRate().get());
+  EXPECT_FALSE(hp.isDesignFlowRateAutosized());
+  EXPECT_EQ(4.0, hp.designSupplyTemperature());
+  ASSERT_TRUE(hp.designTemperatureLift());
+  EXPECT_EQ(5.0, hp.designTemperatureLift().get());
+  EXPECT_FALSE(hp.isDesignTemperatureLiftAutosized());
+  EXPECT_EQ(6.0, hp.sizingFactor());
+  EXPECT_EQ("ConstantFlow", hp.flowMode());
+  EXPECT_EQ("WetBulb", hp.outdoorAirTemperatureCurveInputVariable());
+  EXPECT_EQ("LeavingCondenser", hp.waterTemperatureCurveInputVariable());
+  EXPECT_EQ(curve1.handle(), hp.normalizedCapacityFunctionofTemperatureCurve().handle());
+  EXPECT_EQ(curve2.handle(), hp.fuelEnergyInputRatioFunctionofTemperatureCurve().handle());
+  EXPECT_EQ(curve3.handle(), hp.fuelEnergyInputRatioFunctionofPLRCurve().handle());
+  EXPECT_EQ(0.5, hp.minimumPartLoadRatio());
+  EXPECT_EQ(0.75, hp.maximumPartLoadRatio());
+  EXPECT_EQ("OnDemand", hp.defrostControlType());
+  EXPECT_EQ(0.8, hp.defrostOperationTimeFraction());
+  ASSERT_TRUE(hp.fuelEnergyInputRatioDefrostAdjustmentCurve());
+  EXPECT_EQ(curve4.handle(), hp.fuelEnergyInputRatioDefrostAdjustmentCurve().get().handle());
+  EXPECT_EQ(10.0, hp.resistiveDefrostHeaterCapacity());
+  EXPECT_EQ(9.9, hp.maximumOutdoorDrybulbTemperatureforDefrostOperation());
+  ASSERT_TRUE(hp.cyclingRatioFactorCurve());
+  EXPECT_EQ(curve5.handle(), hp.cyclingRatioFactorCurve().get().handle());
+  EXPECT_EQ(12.0, hp.nominalAuxiliaryElectricPower());
+  ASSERT_TRUE(hp.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(curve6.handle(), hp.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve().get().handle());
+  ASSERT_TRUE(hp.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve());
+  EXPECT_EQ(curve7.handle(), hp.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve().get().handle());
+  EXPECT_EQ(13.0, hp.standbyElectricPower());
+
+  hp.autosizeNominalHeatingCapacity();
+  hp.autosizeDesignFlowRate();
+  hp.autosizeDesignTemperatureLift();
+
+  EXPECT_FALSE(hp.nominalHeatingCapacity());
+  EXPECT_TRUE(hp.isNominalHeatingCapacityAutosized());
+  EXPECT_FALSE(hp.designFlowRate());
+  EXPECT_TRUE(hp.isDesignFlowRateAutosized());
+  EXPECT_FALSE(hp.designTemperatureLift());
+  EXPECT_TRUE(hp.isDesignTemperatureLiftAutosized());
+
+  hp.resetCompanionCoolingHeatPump();
+  hp.resetEndUseSubcategory();
+  hp.resetNominalHeatingCapacity();
+  hp.resetDesignFlowRate();
+  hp.resetFuelEnergyInputRatioDefrostAdjustmentCurve();
+  hp.resetCyclingRatioFactorCurve();
+  hp.resetAuxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve();
+  hp.resetAuxiliaryElectricEnergyInputRatioFunctionofPLRCurve();
+
+  EXPECT_FALSE(hp.companionCoolingHeatPump());
+  EXPECT_EQ("General", hp.endUseSubcategory());
+  EXPECT_TRUE(hp.isEndUseSubcategoryDefaulted());
+  EXPECT_FALSE(hp.nominalHeatingCapacity());
+  EXPECT_FALSE(hp.designFlowRate());
+  EXPECT_FALSE(hp.fuelEnergyInputRatioDefrostAdjustmentCurve());
+  EXPECT_FALSE(hp.cyclingRatioFactorCurve());
+  EXPECT_FALSE(hp.auxiliaryElectricEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_FALSE(hp.auxiliaryElectricEnergyInputRatioFunctionofPLRCurve());
+}
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredHeating_remove) {
+  Model m;
+  HeatPumpAirToWaterFuelFiredHeating hp(m);
+
+  HeatPumpAirToWaterFuelFiredCooling companionHP(m);
+  EXPECT_TRUE(hp.setCompanionCoolingHeatPump(companionHP));
+  EXPECT_TRUE(companionHP.setCompanionHeatingHeatPump(hp));
+
+  auto size = m.modelObjects().size();
+  EXPECT_FALSE(hp.remove().empty());
+  EXPECT_EQ(size - 1, m.modelObjects().size());
+  EXPECT_FALSE(companionHP.companionHeatingHeatPump());
+  EXPECT_EQ(0, m.getConcreteModelObjects<HeatPumpAirToWaterFuelFiredHeating>().size());
+  EXPECT_EQ(1, m.getConcreteModelObjects<HeatPumpAirToWaterFuelFiredCooling>().size());
+}
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredHeating_clone) {
+  Model m;
+  CurveBiquadratic curve1(m);
+  CurveBiquadratic curve2(m);
+  CurveQuadratic curve3(m);
+  HeatPumpAirToWaterFuelFiredHeating hp(m, curve1, curve2, curve3);
+  EXPECT_EQ(2u, m.getConcreteModelObjects<CurveBiquadratic>().size());
+  EXPECT_EQ(1u, m.getConcreteModelObjects<CurveQuadratic>().size());
+
+  HeatPumpAirToWaterFuelFiredCooling companionHP(m);
+  EXPECT_TRUE(hp.setCompanionCoolingHeatPump(companionHP));
+  EXPECT_TRUE(companionHP.setCompanionHeatingHeatPump(hp));
+
+  EXPECT_EQ(4u, m.getConcreteModelObjects<CurveBiquadratic>().size());
+  EXPECT_EQ(2u, m.getConcreteModelObjects<CurveQuadratic>().size());
+
+  PlantLoop p(m);
+  EXPECT_TRUE(p.addSupplyBranchForComponent(hp));
+  EXPECT_TRUE(hp.inletModelObject());
+  EXPECT_TRUE(hp.outletModelObject());
+  EXPECT_TRUE(hp.plantLoop());
+  {
+    Model m2;
+    auto hpClone = hp.clone(m2).cast<HeatPumpAirToWaterFuelFiredHeating>();
+    EXPECT_FALSE(hpClone.companionCoolingHeatPump());
+    EXPECT_FALSE(hpClone.inletModelObject());
+    EXPECT_FALSE(hpClone.outletModelObject());
+    EXPECT_FALSE(hpClone.plantLoop());
+    EXPECT_NE(curve1.handle(), hpClone.normalizedCapacityFunctionofTemperatureCurve().handle());
+    EXPECT_NE(curve2.handle(), hpClone.fuelEnergyInputRatioFunctionofTemperatureCurve().handle());
+    EXPECT_NE(curve3.handle(), hpClone.fuelEnergyInputRatioFunctionofPLRCurve().handle());
+    EXPECT_EQ(2u, m2.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(1u, m2.getConcreteModelObjects<CurveQuadratic>().size());
+  }
+
+  {
+    auto hpClone = hp.clone(m).cast<HeatPumpAirToWaterFuelFiredHeating>();
+    EXPECT_FALSE(hpClone.companionCoolingHeatPump());
+    EXPECT_FALSE(hpClone.inletModelObject());
+    EXPECT_FALSE(hpClone.outletModelObject());
+    EXPECT_FALSE(hpClone.plantLoop());
+    EXPECT_EQ(curve1.handle(), hpClone.normalizedCapacityFunctionofTemperatureCurve().handle());
+    EXPECT_EQ(curve2.handle(), hpClone.fuelEnergyInputRatioFunctionofTemperatureCurve().handle());
+    EXPECT_EQ(curve3.handle(), hpClone.fuelEnergyInputRatioFunctionofPLRCurve().handle());
+    EXPECT_EQ(4u, m.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(2u, m.getConcreteModelObjects<CurveQuadratic>().size());
+  }
+}
+
+TEST_F(ModelFixture, HeatPumpAirToWaterFuelFiredHeating_addToNode) {
+  Model m;
+  HeatPumpAirToWaterFuelFiredHeating hp(m);
+
+  AirLoopHVAC airLoop(m);
+
+  Node supplyOutletNode = airLoop.supplyOutletNode();
+
+  EXPECT_FALSE(hp.addToNode(supplyOutletNode));
+  EXPECT_EQ(2, airLoop.supplyComponents().size());
+
+  Node inletNode = airLoop.zoneSplitter().lastOutletModelObject()->cast<Node>();
+
+  EXPECT_FALSE(hp.addToNode(inletNode));
+  EXPECT_EQ(5, airLoop.demandComponents().size());
+
+  PlantLoop plantLoop(m);
+  supplyOutletNode = plantLoop.supplyOutletNode();
+  EXPECT_TRUE(hp.addToNode(supplyOutletNode));
+  EXPECT_EQ(7, plantLoop.supplyComponents().size());
+
+  Node demandOutletNode = plantLoop.demandOutletNode();
+  EXPECT_FALSE(hp.addToNode(demandOutletNode));
+  EXPECT_EQ(5, plantLoop.demandComponents().size());
+
+  auto hpClone = hp.clone(m).cast<HeatPumpAirToWaterFuelFiredHeating>();
+  supplyOutletNode = plantLoop.supplyOutletNode();
+
+  EXPECT_TRUE(hpClone.addToNode(supplyOutletNode));
+  EXPECT_EQ(9, plantLoop.supplyComponents().size());
+}