Repository: NREL/OpenStudio (language: python)

Issue:
Wrap Coil:Cooling:DX:SingleSpeed:ThermalStorage
Enhancement Request
--------------

Without having this wrapped, you are forced to use an EnergyPlus measure. Here is an example where an EnergyPlus measure broke because of idd changes in an E+ update: https://github.com/NREL/openstudio-load-flexibility-measures-gem/pull/64.



Discussion / hints:

Fix patch:
diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd
index 41670d9174b..5639122d314 100644
--- a/resources/model/OpenStudio.idd
+++ b/resources/model/OpenStudio.idd
@@ -17738,7 +17738,6 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \maximum 1505.0
        \required-field
   A4,  \field Air Inlet Node Name
-       \required-field
        \type object-list
        \required-field
        \object-list ConnectionNames
@@ -18879,6 +18878,782 @@ OS:CoilSystem:IntegratedHeatPump:AirSource,
        \minimum> 0
        \maximum< 10
 
+OS:Coil:Cooling:DX:SingleSpeed:ThermalStorage,
+       \memo Direct expansion (DX) cooling coil and condensing unit (includes electric compressor
+       \memo and condenser fan), single-speed with packaged integrated thermal storage for cooling.
+       \min-fields 99
+  A1 , \field Handle
+       \type handle
+       \required-field
+  A2 , \field Name
+       \required-field
+       \type alpha
+       \reference CoolingCoilsDX
+       \reference CoolingCoilsDXSingleSpeed
+       \reference CoolingCoilsDXMultiModeOrSingleSpeed
+       \reference AFNCoilNames
+       \reference ConnectionObject
+  A3 , \field Availability Schedule
+       \note Availability schedule name for this system. Schedule value > 0 means the system is available.
+       \note If this field is blank, the system is always available.
+       \type object-list
+       \required-field
+       \object-list ScheduleNames
+  A4 , \field Operating Mode Control Method
+       \required-field
+       \type choice
+       \key ScheduledModes
+       \key EMSControlled
+  A5 , \field Operation Mode Control Schedule
+       \note This field is used if the control method is set to ScheduledModes
+       \note Schedule values control operating mode: 0=off, 1=cooling only, 2= cooling and charge,
+       \note 3= cooling and discharge, 4= charge only, and 5= discharge only
+       \type object-list
+       \object-list ScheduleNames
+  A6 , \field Storage Type
+       \type choice
+       \key Water
+       \key Ice
+       \key PropyleneGlycol
+       \key EthyleneGlycol
+       \key R11
+       \key R12
+       \key R22
+       \key R123
+       \key R134a
+       \key R404a
+       \key R407a
+       \key R410a
+       \key NH3
+       \key R507a
+       \key R744
+       \required-field
+  N1,  \field Glycol Concentration
+       \required-field
+       \type integer
+       \minimum 0
+       \maximum 100
+       \note Only used with either "PropyleneGlycol" or "EthyleneGlycol"
+  N2 , \field Fluid Storage Volume
+       \units m3
+       \ip-units gal
+       \type real
+       \minimum> 0
+       \note required field if Storage Type is Water or UserDefinedFluidType
+       \autosizable
+  N3 , \field Ice Storage Capacity
+       \units GJ
+       \required-field
+       \type real
+       \minimum> 0
+       \note required field if Storage Type is Ice
+       \autosizable
+  N4 , \field Storage Capacity Sizing Factor
+       \type real
+       \required-field
+       \units hr
+       \note If one of the previous two fields is set to autocalculate, this determines the storage capacity
+       \note as a function of Cooling Only Mode Rated Total Evaporator Cooling Capacity
+  A7 , \field Storage Tank Ambient Temperature Node
+       \type alpha
+  N5 , \field Storage Tank to Ambient U-value Times Area Heat Transfer Coefficient
+       \type real
+       \units W/K
+       \minimum> 0
+       \required-field
+  N6,  \field Fluid Storage Tank Rating Temperature
+       \type real
+       \required-field
+       \units C
+       \note required field if Storage Type is Water or UserDefinedFluidType
+  N7 , \field Rated Evaporator Air Flow Rate
+       \required-field
+       \type real
+       \units m3/s
+       \minimum> 0
+       \autosizable
+       \note Flow rate corresponding to rated total cooling capacity, Rated SHR and Rated COP
+  A8 , \field Evaporator Air Inlet Node
+       \type object-list
+       \required-field
+       \object-list ConnectionNames
+  A9,  \field Evaporator Air Outlet Node
+       \type object-list
+       \required-field
+       \object-list ConnectionNames
+  A10 ,\field Cooling Only Mode Available
+       \required-field
+       \type choice
+       \key Yes
+       \key No
+  N8 , \field Cooling Only Mode Rated Total Evaporator Cooling Capacity
+       \note required field if Cooling Only Mode is available or if autocalculating sizes
+       \type real
+       \required-field
+       \units W
+       \minimum 0.0
+       \autosizable
+       \note gross capacity excluding supply air fan heat
+       \note rating point: air entering the cooling coil at 26.7 C dry-bulb/19.4 C wet-bulb, and
+       \note air entering the outdoor condenser coil at 35 C dry-bulb/23.9 C wet-bulb
+  N9 , \field Cooling Only Mode Rated Sensible Heat Ratio
+       \note required field if Cooling Only Mode is available
+       \type real
+       \minimum 0.0
+       \maximum 1.0
+       \required-field
+       \note Rated sensible heat ratio (gross sensible capacity/gross total capacity)
+       \note sensible and total capacities do not include supply fan heat
+  N10, \field Cooling Only Mode Rated COP
+       \note Gross cooling capacity divided by power input to the compressor and outdoor fan,
+       \note does not include supply fan heat or supply fan electrical energy input
+       \type real
+       \units W/W
+       \minimum> 0.0
+       \required-field
+       \note required field if Cooling Only Mode is available
+  A11, \field Cooling Only Mode Total Evaporator Cooling Capacity Function of Temperature Curve
+       \note required field if Cooling Only Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \note Any curve or table with two independent variables can be used
+       \note biquadratic curve = a + b*ewb + c*ewb**2 + d*db + e*db**2 + f*ewb*db
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+  A12, \field Cooling Only Mode Total Evaporator Cooling Capacity Function of Flow Fraction Curve
+       \note required field if Cooling Only Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow rate
+  A13, \field Cooling Only Mode Energy Input Ratio Function of Temperature Curve
+       \note required field if Cooling Only Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \note Any curve or table with two independent variables can be used
+       \note curve = a + b*ewb + c*ewb**2 + d*db + e*db**2 + f*ewb*db
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+  A14, \field Cooling Only Mode Energy Input Ratio Function of Flow Fraction Curve
+       \note required field if Cooling Only Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A15, \field Cooling Only Mode Part Load Fraction Correlation Curve
+       \note required field if Cooling Only Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*PLR + c*PLR**2
+       \note cubic curve = a + b*PLR + c*PLR**2 + d*PLR**3
+       \note x = PLR = part load ratio (evaporator cooling load/steady state capacity)
+  A16, \field Cooling Only Mode Sensible Heat Ratio Function of Temperature Curve
+       \note required field if Cooling Only Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \note Any curve or table with two independent variables can be used
+       \note curve = a + b*ewb + c*ewb**2 + d*edb + e*edb**2 + f*ewb*edb
+       \note x = ewb = evaporator entering wet-bulb temperature seen by the cooling coil (C)
+       \note y = edb = evaporator entering dry-bulb temperature seen by the cooling coil (C)
+  A17, \field Cooling Only Mode Sensible Heat Ratio Function of Flow Fraction Curve
+       \note required field if Cooling Only Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A18, \field Cooling And Charge Mode Available
+       \required-field
+       \type choice
+       \key Yes
+       \key No
+  N11 ,\field Cooling And Charge Mode Rated Total Evaporator Cooling Capacity
+       \note required field if Cooling And Charge Mode is available
+       \type real
+       \required-field
+       \units W
+       \minimum 0.0
+       \autosizable
+       \note gross capacity excluding supply air fan heat
+       \note rating point: air entering the cooling coil at 26.7 C dry-bulb/19.4 C wet-bulb, and
+       \note air entering the outdoor condenser coil at 35 C dry-bulb/23.9 C wet-bulb
+       \note thermal storage tank at Fluid Storage Tank Rating Temperature (water or fluid) or storage faction of 0.5 (ice)
+  N12, \field Cooling And Charge Mode Capacity Sizing Factor
+       \type real
+       \required-field
+       \note If previous field is autocalculate, this determines the evaporator capacity
+       \note as a multiplier on the Cooling Only Mode Rated Total Evaporator Cooling Capacity
+  N13, \field Cooling And Charge Mode Rated Storage Charging Capacity
+       \note required field if Cooling And Charge Mode is available
+       \type real
+       \required-field
+       \units W
+       \minimum 0.0
+       \note net capacity including any internal devices
+       \note rating point: air entering the cooling coil at 26.7 C dry-bulb/19.4 C wet-bulb, and
+       \note air entering the outdoor condenser coil at 35 C dry-bulb/23.9 C wet-bulb
+       \note thermal storage tank at Fluid Storage Tank Rating Temperature (water or fluid) or storage faction of 0.5 (ice)
+       \autosizable
+  N14, \field Cooling And Charge Mode Storage Capacity Sizing Factor
+       \type real
+       \required-field
+       \note If previous field is autocalculate, this determines the storage cooling capacity
+       \note as a multiplier on the Cooling Only Mode Rated Total Evaporator Cooling Capacity
+  N15, \field Cooling And Charge Mode Rated Sensible Heat Ratio
+       \note required field if Cooling And Charge Mode is available
+       \type real
+       \minimum 0.0
+       \maximum 1.0
+       \required-field
+       \note Rated sensible heat ratio (gross sensible evaporator capacity/gross total evaporator capacity)
+       \note sensible and total capacities do not include supply fan heat
+  N16, \field Cooling And Charge Mode Cooling Rated COP
+       \note Gross evaporator cooling capacity divided by power input to the compressor (for cooling) and outdoor fan,
+       \note does not include supply fan heat or supply fan electrical energy input
+       \type real
+       \units W/W
+       \minimum 0.0
+       \required-field
+       \note required field if Cooling And Charge Mode is available
+  N17, \field Cooling And Charge Mode Charging Rated COP
+       \note net cooling capacity divided by power input to the compressor (for charging) and outdoor fan,
+       \note includes any internal devices
+       \type real
+       \units W/W
+       \minimum> 0.0
+       \required-field
+       \note required field if Cooling And Charge Mode is available
+  A19, \field Cooling And Charge Mode Total Evaporator Cooling Capacity Function of Temperature Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list TrivariateFunctions
+       \note Allowed curve or table objects are Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = db, z = stes)
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A20, \field Cooling And Charge Mode Total Evaporator Cooling Capacity Function of Flow Fraction Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A21, \field Cooling And Charge Mode Evaporator Energy Input Ratio Function of Temperature Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list TrivariateFunctions
+       \note Allowed curve or table objects are Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = db, z = stes)
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A22, \field Cooling And Charge Mode Evaporator Energy Input Ratio Function of Flow Fraction Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A23, \field Cooling And Charge Mode Evaporator Part Load Fraction Correlation Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*PLR + c*PLR**2
+       \note cubic curve = a + b*PLR + c*PLR**2 + d*PLR**3
+       \note x = PLR = part load ratio (evaporator cooling load/steady state capacity)
+  A24, \field Cooling And Charge Mode Storage Charge Capacity Function of Temperature Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list TrivariateFunctions
+       \note Allowed curve or table objects are Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = db, z = stes)
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A25, \field Cooling And Charge Mode Storage Charge Capacity Function of Total Evaporator PLR Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*PLR + c*PLR**2
+       \note cubic curve = a + b*PLR + c*PLR**2 + d*PLR**3
+       \note x = PLR = part load ratio (evaporator cooling load/steady state capacity)
+  A26, \field Cooling And Charge Mode Storage Energy Input Ratio Function of Temperature Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list TrivariateFunctions
+       \note Allowed curve or table objects are Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = db, z = stes)
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A27, \field Cooling And Charge Mode Storage Energy Input Ratio Function of Flow Fraction Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A28, \field Cooling And Charge Mode Storage Energy Part Load Fraction Correlation Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*PLR + c*PLR**2
+       \note cubic curve = a + b*PLR + c*PLR**2 + d*PLR**3
+       \note x = PLR = part load ratio (evaporator cooling load/steady state capacity)
+  A29, \field Cooling And Charge Mode Sensible Heat Ratio Function of Temperature Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \object-list TrivariateFunctions
+       \note Curves or tables with either two or three independent variables can be used.
+       \note Curve:Biquadratic, Table:Lookup, Curve:Bicubic and Curve:QuadraticLinear allowed
+       \note curve = a + b*ewb + c*ewb**2 + d*edb + e*edb**2 + f*ewb*edb
+       \note x = ewb = entering wet-bulb temperature seen by the cooling coil (C)
+       \note y = edb = entering dry-bulb temperature seen by the cooling coil (C)
+       \note Also allows Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = edb, z = stes)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A30, \field Cooling And Charge Mode Sensible Heat Ratio Function of Flow Fraction Curve
+       \note required field if Cooling And Charge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A31, \field Cooling And Discharge Mode Available
+       \required-field
+       \type choice
+       \key Yes
+       \key No
+  N18, \field Cooling And Discharge Mode Rated Total Evaporator Cooling Capacity
+       \note required field if Cooling And Discharge Mode is available
+       \type real
+       \units W
+       \required-field
+       \minimum 0.0
+       \autosizable
+       \note gross capacity excluding supply air fan heat
+       \note rating point: air entering the cooling coil at 26.7 C dry-bulb/19.4 C wet-bulb, and
+       \note air entering the outdoor condenser coil at 35 C dry-bulb/23.9 C wet-bulb
+       \note thermal storage tank at Fluid Storage Tank Rating Temperature (water or fluid) or storage faction of 0.5 (ice)
+  N19, \field Cooling And Discharge Mode Evaporator Capacity Sizing Factor
+       \type real
+       \required-field
+       \note If previous field is autocalculate, this determines the charging capacity
+       \note as a multiplier on the Cooling Only Mode Rated Total Evaporator Cooling Capacity
+  N20, \field Cooling And Discharge Mode Rated Storage Discharging Capacity
+       \note required field if Cooling And Discharge Mode is available
+       \type real
+       \required-field
+       \units W
+       \minimum 0.0
+       \note net capacity including any internal devices
+       \note rating point: air entering the cooling coil at 26.7 C dry-bulb/19.4 C wet-bulb, and
+       \note air entering the outdoor condenser coil at 35 C dry-bulb/23.9 C wet-bulb
+       \note thermal storage tank at 26.7 C (water) or storage faction of 0.5 (ice)
+       \autosizable
+  N21, \field Cooling And Discharge Mode Storage Discharge Capacity Sizing Factor
+       \type real
+       \required-field
+       \note If previous field is autocalculate, this determines the charging capacity
+       \note as a multiplier on the Cooling Only Mode Rated Total Evaporator Cooling Capacity
+  N22, \field Cooling And Discharge Mode Rated Sensible Heat Ratio
+       \note required field if Cooling And Discharge Mode is available
+       \type real
+       \minimum 0.0
+       \maximum 1.0
+       \required-field
+       \note Rated sensible heat ratio (gross sensible evaporator capacity/gross total evaporator capacity)
+       \note sensible and total capacities do not include supply fan heat
+  N23, \field Cooling And Discharge Mode Cooling Rated COP
+       \note Gross evaporator cooling capacity divided by power input to the compressor (for cooling) and outdoor fan,
+       \note does not include supply fan heat or supply fan electrical energy input
+       \type real
+       \units W/W
+       \minimum 0.0
+       \required-field
+       \note required field if Cooling And Discharge Mode is available
+  N24, \field Cooling And Discharge Mode Discharging Rated COP
+       \note gross cooling capacity divided by power input to the compressor (for discharging),
+       \note includes any internal devices for discharging storage but not supply fan
+       \type real
+       \units W/W
+       \minimum> 0.0
+       \required-field
+       \note required field if Cooling And Discharge Mode is available
+  A32, \field Cooling And Discharge Mode Total Evaporator Cooling Capacity Function of Temperature Curve
+       \note required field if Cooling Only Mode is available
+       \type object-list
+       \object-list TrivariateFunctions
+       \note Allowed curve or table objects are Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = db, z = stes)
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A33, \field Cooling And Discharge Mode Total Evaporator Cooling Capacity Function of Flow Fraction Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A34, \field Cooling And Discharge Mode Evaporator Energy Input Ratio Function of Temperature Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list TrivariateFunctions
+       \note Allowed curve or table objects are Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = db, z = stes)
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A35, \field Cooling And Discharge Mode Evaporator Energy Input Ratio Function of Flow Fraction Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note ff = Fraction of the full load evaporator air flow
+  A36, \field Cooling And Discharge Mode Evaporator Part Load Fraction Correlation Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*PLR + c*PLR**2
+       \note cubic curve = a + b*PLR + c*PLR**2 + d*PLR**3
+       \note x = PLR = part load ratio (evaporator cooling load/steady state capacity)
+  A37, \field Cooling And Discharge Mode Storage Discharge Capacity Function of Temperature Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list TrivariateFunctions
+       \note Allowed curve or table objects are Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = db, z = stes)
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A38, \field Cooling And Discharge Mode Storage Discharge Capacity Function of Flow Fraction Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note ff = Fraction of the full load evaporator air flow
+  A39, \field Cooling And Discharge Mode Storage Discharge Capacity Function of Total Evaporator PLR Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*PLR + c*PLR**2
+       \note cubic curve = a + b*PLR + c*PLR**2 + d*PLR**3
+       \note x =PLR = part load ratio (evaporator cooling load/steady state capacity)
+  A40, \field Cooling And Discharge Mode Storage Energy Input Ratio Function of Temperature Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list TrivariateFunctions
+       \note Allowed curve or table objects are Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = db, z = stes)
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = db = dry-bulb temperature seen by the condenser (C)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A41, \field Cooling And Discharge Mode Storage Energy Input Ratio Function of Flow Fraction Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A42, \field Cooling And Discharge Mode Storage Energy Part Load Fraction Correlation Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*PLR + c*PLR**2
+       \note cubic curve = a + b*PLR + c*PLR**2 + d*PLR**3
+       \note x = PLR = part load ratio (evaporator cooling load/steady state capacity)
+  A43, \field Cooling And Discharge Mode Sensible Heat Ratio Function of Temperature Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \object-list TrivariateFunctions
+       \note Curves or tables with either two or three independent variables can be used.
+       \note curve = a + b*ewb + c*ewb**2 + d*edb + e*edb**2 + f*ewb*edb
+       \note x = ewb = entering wet-bulb temperature seen by the cooling coil (C)
+       \note y = edb = entering dry-bulb temperature seen by the cooling coil (C)
+       \note Also allows Curve:Triquadratic and Table:Lookup
+       \note curve or table = func(x = ewb, y = edb, z = stes)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A44, \field Cooling And Discharge Mode Sensible Heat Ratio Function of Flow Fraction Curve
+       \note required field if Cooling And Discharge Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A45, \field Charge Only Mode Available
+       \required-field
+       \type choice
+       \key Yes
+       \key No
+  N25, \field Charge Only Mode Rated Storage Charging Capacity
+       \note required field if Charge Only  Mode is available
+       \type real
+       \required-field
+       \units W
+       \minimum 0.0
+       \note net capacity including any internal devices
+       \note air entering the outdoor condenser coil at 35 C dry-bulb/23.9 C wet-bulb
+       \note thermal storage tank at 26.7 C (water) or storage faction of 0.5 (ice)
+       \autosizable
+  N26, \field Charge Only Mode Capacity Sizing Factor
+       \type real
+       \required-field
+       \note If previous field is autocalculate, this determines the charging capacity
+       \note as a multiplier on the Cooling Only Mode Rated Total Evaporator Cooling Capacity
+  N27, \field Charge Only Mode Charging Rated COP
+       \note net cooling capacity divided by power input to the compressor (for charging) and outdoor fan,
+       \note includes any internal devices
+       \type real
+       \units W/W
+       \minimum> 0.0
+       \required-field
+       \note required field if Charge Only Mode is available
+  A46, \field Charge Only Mode Storage Charge Capacity Function of Temperature Curve
+       \note required field if Charge Only Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \note Any curve or table with two independent variables can be used
+       \note curve = a + b*db + c*db**2 + d*stes + e*stes**2 + f*db*stes
+       \note x = db = dry-bulb temperature seen by the condenser (C)
+       \note y = stes = state of thermal energy storage (C or fraction)
+  A47, \field Charge Only Mode Storage Energy Input Ratio Function of Temperature Curve
+       \note required field if Charge Only Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \note Any curve or table with two independent variables can be used
+       \note curve = a + b*db + c*db**2 + d*stes + e*stes**2 + f*db*stes
+       \note x = db = dry-bulb temperature seen by the condenser (C)
+       \note y = stes = state of thermal energy storage (C or fraction)
+  A48, \field Discharge Only Mode Available
+       \required-field
+       \type choice
+       \key Yes
+       \key No
+  N28, \field Discharge Only Mode Rated Storage Discharging Capacity
+       \note required field if Discharge Only Mode is available
+       \type real
+       \required-field
+       \units W
+       \minimum 0.0
+       \note net capacity including any internal devices
+       \note rating point: air entering the cooling coil at 26.7 C dry-bulb/19.4 C wet-bulb, and
+       \note thermal storage tank at 26.7 C (water) or storage faction of 0.5 (ice)
+       \autosizable
+  N29, \field Discharge Only Mode Capacity Sizing Factor
+       \type real
+       \required-field
+       \note If previous field is autocalculate, this determines the discharging capacity
+       \note as a multiplier on the Cooling Only Mode Rated Total Evaporator Cooling Capacity
+  N30, \field Discharge Only Mode Rated Sensible Heat Ratio
+       \note required field if Discharge Only Mode is available
+       \type real
+       \minimum 0.0
+       \maximum 1.0
+       \required-field
+       \note Rated sensible heat ratio (gross sensible evaporator capacity/gross total evaporator capacity)
+       \note sensible and total capacities do not include supply fan heat
+  N31, \field Discharge Only Mode Rated COP
+       \note required field if Discharge Only Mode is available
+       \note gross cooling capacity divided by power input to the compressor (for discharging),
+       \note includes any internal devices for discharging storage but not supply fan
+       \type real
+       \units W/W
+       \minimum> 0.0
+       \required-field
+  A49, \field Discharge Only Mode Storage Discharge Capacity Function of Temperature Curve
+       \note required field if Discharge Only Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \note Any curve or table with two independent variables can be used
+       \note curve = a + b*ewb + c*ewb**2 + d*stes + e*stes**2 + f*ewb*stes
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = stes = state of thermal energy storage (C or fraction)
+  A50, \field Discharge Only Mode Storage Discharge Capacity Function of Flow Fraction Curve
+       \note required field if Discharge Only Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A51, \field Discharge Only Mode Energy Input Ratio Function of Temperature Curve
+       \note required field if Discharge Only Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \note Any curve or table with two independent variables can be used
+       \note curve = a + b*ewb + c*ewb**2 + d*stes + e*stes**2 + f*ewb*stes
+       \note x = ewb = evaporator entering wet-bulb temperature (C)
+       \note y = stes = state of thermal energy storage (C or fraction)
+  A52, \field Discharge Only Mode Energy Input Ratio Function of Flow Fraction Curve
+       \note required field if Discharge Only Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note x = ff = Fraction of the full load evaporator air flow
+  A53, \field Discharge Only Mode Part Load Fraction Correlation Curve
+       \note required field if Discharge Only Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*PLR + c*PLR**2
+       \note cubic curve = a + b*PLR + c*PLR**2 + d*PLR**3
+  A54, \field Discharge Only Mode Sensible Heat Ratio Function of Temperature Curve
+       \note required field if Discharge Only Mode is available
+       \type object-list
+       \object-list BivariateFunctions
+       \object-list TrivariateFunctions
+       \note Curves or tables with either two or three independent variables can be used.
+       \note For two independent variables:
+       \note x = ewb = entering wet-bulb temperature seen by the cooling coil (C)
+       \note y = edb = entering dry-bulb temperature seen by the cooling coil (C)
+       \note For three independent variables:
+       \note curve or table = func(x = ewb, y = edb, z = stes)
+       \note z = stes = state of thermal energy storage (C or fraction)
+  A55, \field Discharge Only Mode Sensible Heat Ratio Function of Flow Fraction Curve
+       \note required field if Discharge Only Mode is available
+       \type object-list
+       \object-list UnivariateFunctions
+       \note Any curve or table with one independent variable can be used
+       \note quadratic curve = a + b*ff + c*ff**2
+       \note cubic curve = a + b*ff + c*ff**2 + d*ff**3
+       \note ff = Fraction of the full load evaporator air flow
+  N32, \field Ancillary Electric Power
+       \type real
+       \required-field
+       \units W
+       \minimum 0.0
+       \note controls and miscellaneous standby ancillary electric power draw, when available
+  N33, \field Cold Weather Operation Minimum Outdoor Air Temperature
+       \type real
+       \units C
+  N34, \field Cold Weather Operation Ancillary Power
+       \type real
+       \required-field
+       \units W
+       \minimum 0.0
+  A56, \field Condenser Air Inlet Node
+       \note Enter the name of an outdoor air node. This node name is also specified in
+       \note an OutdoorAir:Node or OutdoorAir:NodeList object.
+       \type alpha
+  A57, \field Condenser Air Outlet Node
+       \type alpha
+  N35, \field Condenser Design Air Flow Rate
+       \required-field
+       \type real
+       \units m3/s
+       \minimum> 0.0
+       \autosizable
+       \note Used to calculate condenser leaving conditions and water use if evaporatively cooled.
+  N36, \field Condenser Air Flow Sizing Factor
+       \type real
+       \required-field
+       \note If previous field is autocalculate, this determines the condenser air flow size as a
+       \note multiplier on the Rated Evaporator Air Flow Rate.
+  A58, \field Condenser Type
+       \type choice
+       \key AirCooled
+       \key EvaporativelyCooled
+       \required-field
+  N37, \field Evaporative Condenser Effectiveness
+       \note required field if condenser type is evaporatively cooled
+       \type real
+       \units dimensionless
+       \minimum> 0.0
+       \maximum 1.0
+       \required-field
+  N38, \field Evaporative Condenser Pump Rated Power Consumption
+       \type real
+       \units W
+       \minimum 0.0
+       \required-field
+       \autosizable
+       \note Rated power consumed by the evaporative condenser's water pump
+  N39, \field Basin Heater Capacity
+       \type real
+       \units W/K
+       \minimum 0.0
+       \required-field
+       \note This field is only used for Condenser Type = EvaporativelyCooled and for periods
+       \note when the basin heater is available (field Basin Heater Operating Schedule Name).
+       \note For this situation, the heater maintains the basin water temperature at the basin heater
+       \note setpoint temperature when the outdoor air temperature falls below the setpoint temperature.
+       \note The basin heater only operates when the DX coil is off.
+       \note If this field is blank, the basin heater is always available.
+  N40, \field Basin Heater Setpoint Temperature
+       \type real
+       \units C
+       \minimum 2.0
+       \required-field
+       \note This field is only used for Condenser Type = EvaporativelyCooled.
+       \note Enter the outdoor dry-bulb temperature when the basin heater turns on.
+  A59, \field Basin Heater Availability Schedule
+       \type object-list
+       \object-list ScheduleNames
+       \note This field is only used for Condenser Type = EvaporativelyCooled.
+       \note Schedule values greater than 0 allow the basin heater to operate whenever the outdoor
+       \note air dry-bulb temperature is below the basin heater setpoint temperature.
+       \note If a schedule name is not entered, the basin heater is allowed to operate
+       \note throughout the entire simulation.
+  A60, \field Supply Water Storage Tank
+       \type object-list
+       \object-list WaterStorageTankNames
+  A61, \field Condensate Collection Water Storage Tank
+       \type object-list
+       \object-list WaterStorageTankNames
+  A62, \field Storage Tank Plant Connection Inlet Node
+       \type alpha
+  A63, \field Storage Tank Plant Connection Outlet Node
+       \type alpha
+  N41, \field Storage Tank Plant Connection Design Flow Rate
+       \type real
+       \units m3/s
+       \ip-units gal/min
+       \minimum 0.0
+  N42, \field Storage Tank Plant Connection Heat Transfer Effectiveness
+       \type real
+       \minimum 0.0
+       \maximum 1.0
+       \default 0.7
+  N43, \field Storage Tank Minimum Operating Limit Fluid Temperature
+       \type real
+       \units C
+       \note For fluid storage tanks only, minimum limit for storage tank
+       \note If omitted,then the minimum temperature limit is that used for fluid property data.
+  N44; \field Storage Tank Maximum Operating Limit Fluid Temperature
+       \type real
+       \units C
+       \note For fluid storage tanks only, maximum limit for storage tank
+       \note If omitted,then the maximum temperature limit is that used for fluid property data.
+
 OS:Coil:Cooling:DX:VariableRefrigerantFlow,
   A1, \field Handle
        \type handle
diff --git a/src/energyplus/CMakeLists.txt b/src/energyplus/CMakeLists.txt
index 9caeb1792dd..36434c2bdf6 100644
--- a/src/energyplus/CMakeLists.txt
+++ b/src/energyplus/CMakeLists.txt
@@ -74,6 +74,7 @@ set(${target_name}_src
   ForwardTranslator/ForwardTranslateCoilCoolingDXCurveFitSpeed.cpp
   ForwardTranslator/ForwardTranslateCoilCoolingDXMultiSpeed.cpp
   ForwardTranslator/ForwardTranslateCoilCoolingDXSingleSpeed.cpp
+  ForwardTranslator/ForwardTranslateCoilCoolingDXSingleSpeedThermalStorage.cpp
   ForwardTranslator/ForwardTranslateCoilCoolingDXTwoSpeed.cpp
   ForwardTranslator/ForwardTranslateCoilCoolingDXTwoStageWithHumidityControlMode.cpp
   ForwardTranslator/ForwardTranslateCoilCoolingDXVariableRefrigerantFlow.cpp
@@ -692,6 +693,7 @@ set(${target_name}_test_src
   Test/CoilCoolingDXCurveFitOperatingMode_GTest.cpp
   Test/CoilCoolingDXCurveFitSpeed_GTest.cpp
   Test/CoilCoolingDXSingleSpeed_GTest.cpp
+  Test/CoilCoolingDXSingleSpeedThermalStorage_GTest.cpp
   Test/CoilCoolingDXMultiSpeed_GTest.cpp
   Test/CoilCoolingDXTwoSpeed_GTest.cpp
   Test/CoilCoolingDXTwoStageWithHumidityControlMode_GTest.cpp
diff --git a/src/energyplus/ForwardTranslator.cpp b/src/energyplus/ForwardTranslator.cpp
index 68816a177f4..b87fdfd5809 100644
--- a/src/energyplus/ForwardTranslator.cpp
+++ b/src/energyplus/ForwardTranslator.cpp
@@ -1003,6 +1003,15 @@ namespace energyplus {
         }
         break;
       }
+      case openstudio::IddObjectType::OS_Coil_Cooling_DX_SingleSpeed_ThermalStorage: {
+        auto coil = modelObject.cast<CoilCoolingDXSingleSpeedThermalStorage>();
+        if (isHVACComponentWithinUnitary(coil)) {
+          retVal = translateCoilCoolingDXSingleSpeedThermalStorageWithoutUnitary(coil);
+        } else {
+          retVal = translateCoilCoolingDXSingleSpeedThermalStorage(coil);
+        }
+        break;
+      }
       case openstudio::IddObjectType::OS_Coil_Cooling_DX_MultiSpeed: {
         auto coil = modelObject.cast<CoilCoolingDXMultiSpeed>();
         retVal = translateCoilCoolingDXMultiSpeed(coil);
@@ -3459,6 +3468,7 @@ namespace energyplus {
       // IddObjectType::OS_Coil_Cooling_DX_CurveFit_Speed,
 
       IddObjectType::OS_Coil_Cooling_DX_SingleSpeed,
+      // IddObjectType::OS_Coil_Cooling_DX_SingleSpeed_ThermalStorage,
       IddObjectType::OS_Coil_Cooling_DX_TwoSpeed,
       IddObjectType::OS_Coil_Cooling_Water,
       IddObjectType::OS_Coil_Cooling_WaterToAirHeatPump_EquationFit,
diff --git a/src/energyplus/ForwardTranslator.hpp b/src/energyplus/ForwardTranslator.hpp
index 98fe36fb01e..adda3d13d83 100644
--- a/src/energyplus/ForwardTranslator.hpp
+++ b/src/energyplus/ForwardTranslator.hpp
@@ -110,6 +110,7 @@ namespace model {
   class CoilCoolingDXCurveFitSpeed;
   class CoilCoolingDXMultiSpeed;
   class CoilCoolingDXSingleSpeed;
+  class CoilCoolingDXSingleSpeedThermalStorage;
   class CoilCoolingDXTwoSpeed;
   class CoilCoolingDXTwoStageWithHumidityControlMode;
   class CoilCoolingDXVariableRefrigerantFlow;
@@ -759,6 +760,11 @@ namespace energyplus {
 
     boost::optional<IdfObject> translateCoilCoolingDXSingleSpeedWithoutUnitary(model::CoilCoolingDXSingleSpeed& modelObject);
 
+    boost::optional<IdfObject> translateCoilCoolingDXSingleSpeedThermalStorage(model::CoilCoolingDXSingleSpeedThermalStorage& modelObject);
+
+    boost::optional<IdfObject>
+      translateCoilCoolingDXSingleSpeedThermalStorageWithoutUnitary(model::CoilCoolingDXSingleSpeedThermalStorage& modelObject);
+
     boost::optional<IdfObject> translateCoilCoolingDX(model::CoilCoolingDX& modelObject);
 
     boost::optional<IdfObject> translateCoilCoolingDXWithoutUnitary(model::CoilCoolingDX& modelObject);
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp
index ed7d7c34473..52e61b813c9 100644
--- a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp
@@ -59,6 +59,7 @@
 #include "../../model/UnitarySystemPerformanceMultispeed_Impl.hpp"
 #include <utilities/idd/AirLoopHVAC_UnitarySystem_FieldEnums.hxx>
 #include <utilities/idd/Coil_Cooling_DX_SingleSpeed_FieldEnums.hxx>
+#include <utilities/idd/Coil_Cooling_DX_SingleSpeed_ThermalStorage_FieldEnums.hxx>
 #include <utilities/idd/Coil_Cooling_DX_TwoSpeed_FieldEnums.hxx>
 #include <utilities/idd/Coil_Cooling_DX_TwoStageWithHumidityControlMode_FieldEnums.hxx>
 #include <utilities/idd/Coil_Cooling_DX_MultiSpeed_FieldEnums.hxx>
@@ -683,6 +684,9 @@ namespace energyplus {
       if (_coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_DX_SingleSpeed) {
         _coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirInletNodeName, inletNodeName);
         _coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirOutletNodeName, outletNodeName);
+      } else if (_coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_DX_SingleSpeed_ThermalStorage) {
+        _coolingCoil->setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirInletNodeName, inletNodeName);
+        _coolingCoil->setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirOutletNodeName, outletNodeName);
       } else if (_coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_DX_TwoSpeed) {
         _coolingCoil->setString(Coil_Cooling_DX_TwoSpeedFields::AirInletNodeName, inletNodeName);
         _coolingCoil->setString(Coil_Cooling_DX_TwoSpeedFields::AirOutletNodeName, outletNodeName);
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXSingleSpeedThermalStorage.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXSingleSpeedThermalStorage.cpp
new file mode 100644
index 00000000000..62a4ca3fd9d
--- /dev/null
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXSingleSpeedThermalStorage.cpp
@@ -0,0 +1,934 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2023, 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/CoilCoolingDXSingleSpeedThermalStorage.hpp"
+
+#include "../../model/Schedule.hpp"
+#include "../../model/Schedule_Impl.hpp"
+#include "../../model/Node.hpp"
+#include "../../model/Node_Impl.hpp"
+#include "../../model/Curve.hpp"
+#include "../../model/Curve_Impl.hpp"
+// #include "../../model/WaterStorageTank.hpp"
+// #include "../../model/WaterStorageTank_Impl.hpp"
+
+#include <utilities/idd/CoilSystem_Cooling_DX_FieldEnums.hxx>
+#include <utilities/idd/Coil_Cooling_DX_SingleSpeed_ThermalStorage_FieldEnums.hxx>
+#include <utilities/idd/FluidProperties_Name_FieldEnums.hxx>
+#include <utilities/idd/IddEnums.hxx>
+
+using namespace openstudio::model;
+
+namespace openstudio {
+
+namespace energyplus {
+
+  boost::optional<IdfObject>
+    ForwardTranslator::translateCoilCoolingDXSingleSpeedThermalStorageWithoutUnitary(model::CoilCoolingDXSingleSpeedThermalStorage& modelObject) {
+    // Instantiate an IdfObject of the class to store the values
+    IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::Coil_Cooling_DX_SingleSpeed_ThermalStorage, modelObject);
+
+    // Availability Schedule Name: Required Object
+    Schedule availabilitySchedule = modelObject.availabilitySchedule();
+    if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(availabilitySchedule)) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::AvailabilityScheduleName, wo_->nameString());
+    }
+
+    // Operating Mode Control Method: Required String
+    const std::string operatingModeControlMethod = modelObject.operatingModeControlMethod();
+    idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperatingModeControlMethod, operatingModeControlMethod);
+
+    // Operation Mode Control Schedule Name: Optional Object
+    if (boost::optional<Schedule> operationModeControlSchedule_ = modelObject.operationModeControlSchedule()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(operationModeControlSchedule_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperationModeControlScheduleName, wo_->nameString());
+      }
+    }
+
+    // Storage Type: Required String
+    const std::string storageType = modelObject.storageType();
+    idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageType, storageType);
+
+    if (boost::optional<std::string> s_ = modelObject.storageType()) {
+      if (istringEqual(s_.get(), "PropyleneGlycol") || istringEqual(s_.get(), "EthyleneGlycol")) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageType, "UserDefinedFluidType");
+        boost::optional<int> gc = modelObject.glycolConcentration();
+        if (gc) {
+          boost::optional<IdfObject> fluidProperties = createFluidProperties(s_.get(), gc.get());
+          if (fluidProperties) {
+            boost::optional<std::string> fluidPropertiesName = fluidProperties->getString(FluidProperties_NameFields::FluidName, true);
+            if (fluidPropertiesName) {
+              idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::UserDefinedFluidType, fluidPropertiesName.get());
+            }
+          }
+        }
+      } else {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageType, s_.get());
+      }
+    }
+
+    if (modelObject.isFluidStorageVolumeAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageVolume, "Autosize");
+    } else {
+      // Fluid Storage Volume: boost::optional<double>
+      if (boost::optional<double> fluidStorageVolume_ = modelObject.fluidStorageVolume()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageVolume, fluidStorageVolume_.get());
+      }
+    }
+
+    if (modelObject.isIceStorageCapacityAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::IceStorageCapacity, "Autosize");
+    } else {
+      // Ice Storage Capacity: boost::optional<double>
+      if (boost::optional<double> iceStorageCapacity_ = modelObject.iceStorageCapacity()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::IceStorageCapacity, iceStorageCapacity_.get());
+      }
+    }
+
+    // Storage Capacity Sizing Factor: boost::optional<double>
+    if (boost::optional<double> storageCapacitySizingFactor_ = modelObject.storageCapacitySizingFactor()) {
+      idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageCapacitySizingFactor, storageCapacitySizingFactor_.get());
+    }
+
+    // Storage Tank Ambient Temperature Node Name: Required Node
+    std::string storageTankAmbientTemperatureNodeName(modelObject.nameString() + " Storage Tank Ambient Temperature Node");
+    // Create an OutdoorAir:NodeList for the storage tank conditions to be set directly from weather file
+    IdfObject oaNodeListIdf(openstudio::IddObjectType::OutdoorAir_NodeList);
+    oaNodeListIdf.setString(0, storageTankAmbientTemperatureNodeName);
+    m_idfObjects.push_back(oaNodeListIdf);
+    idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankAmbientTemperatureNodeName,
+                        storageTankAmbientTemperatureNodeName);
+
+    // Storage Tank to Ambient U-value Times Area Heat Transfer Coefficient: Required Double
+    const double storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient =
+      modelObject.storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient,
+                        storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient);
+
+    // Fluid Storage Tank Rating Temperature: Required Double
+    const double fluidStorageTankRatingTemperature = modelObject.fluidStorageTankRatingTemperature();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageTankRatingTemperature, fluidStorageTankRatingTemperature);
+
+    if (modelObject.isRatedEvaporatorAirFlowRateAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::RatedEvaporatorAirFlowRate, "Autosize");
+    } else {
+      // Rated Evaporator Air Flow Rate: boost::optional<double>
+      if (boost::optional<double> ratedEvaporatorAirFlowRate_ = modelObject.ratedEvaporatorAirFlowRate()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::RatedEvaporatorAirFlowRate, ratedEvaporatorAirFlowRate_.get());
+      }
+    }
+
+    // Evaporator Air Inlet Node Name: Required Node
+    if (auto mo = modelObject.inletModelObject()) {
+      if (auto node = mo->optionalCast<Node>()) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirInletNodeName, node->name().get());
+      }
+    }
+
+    // Evaporator Air Outlet Node Name: Required Node
+    if (auto mo = modelObject.outletModelObject()) {
+      if (auto node = mo->optionalCast<Node>()) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirOutletNodeName, node->name().get());
+      }
+    }
+
+    bool coolingOnlyModeAvailable = modelObject.coolingOnlyModeAvailable();
+    bool coolingAndChargeModeAvailable = modelObject.coolingAndChargeModeAvailable();
+    bool coolingAndDischargeModeAvailable = modelObject.coolingAndDischargeModeAvailable();
+    bool chargeOnlyModeAvailable = modelObject.chargeOnlyModeAvailable();
+    bool dischargeOnlyModeAvailable = modelObject.dischargeOnlyModeAvailable();
+
+    // Cooling Only Mode Available: Required Boolean
+    if (coolingOnlyModeAvailable) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeAvailable, "Yes");
+    } else {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeAvailable, "No");
+    }
+
+    // Cooling Only Mode Rated Total Evaporator Cooling Capacity
+    if (modelObject.isCoolingOnlyModeRatedTotalEvaporatorCoolingCapacityAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedTotalEvaporatorCoolingCapacity, "Autosize");
+    } else {
+      if (boost::optional<double> coolingOnlyModeRatedTotalEvaporatorCoolingCapacity_ =
+            modelObject.coolingOnlyModeRatedTotalEvaporatorCoolingCapacity()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedTotalEvaporatorCoolingCapacity,
+                            coolingOnlyModeRatedTotalEvaporatorCoolingCapacity_.get());
+      }
+    }
+
+    // Cooling Only Mode Rated Sensible Heat Ratio: Required Double
+    const double coolingOnlyModeRatedSensibleHeatRatio = modelObject.coolingOnlyModeRatedSensibleHeatRatio();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedSensibleHeatRatio,
+                        coolingOnlyModeRatedSensibleHeatRatio);
+
+    // Cooling Only Mode Rated COP: Required Double
+    const double coolingOnlyModeRatedCOP = modelObject.coolingOnlyModeRatedCOP();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedCOP, coolingOnlyModeRatedCOP);
+
+    // Cooling Only Mode Total Evaporator Cooling Capacity Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve_ =
+          modelObject.coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling Only Mode Total Evaporator Cooling Capacity Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve_ =
+          modelObject.coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling Only Mode Energy Input Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve_ =
+          modelObject.coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling Only Mode Energy Input Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve_ =
+          modelObject.coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling Only Mode Part Load Fraction Correlation Curve Name: Optional Object
+    if (boost::optional<Curve> coolingOnlyModePartLoadFractionCorrelationCurve_ = modelObject.coolingOnlyModePartLoadFractionCorrelationCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingOnlyModePartLoadFractionCorrelationCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModePartLoadFractionCorrelationCurveName, wo_->nameString());
+      }
+    }
+
+    // Cooling Only Mode Sensible Heat Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve_ =
+          modelObject.coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling Only Mode Sensible Heat Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve_ =
+          modelObject.coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Available: Required Boolean
+    if (coolingAndChargeModeAvailable) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeAvailable, "Yes");
+    } else {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeAvailable, "No");
+    }
+
+    // Cooling And Charge Mode Rated Total Evaporator Cooling Capacity
+    if (modelObject.isCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacityAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity, "Autosize");
+    } else {
+      if (boost::optional<double> coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity_ =
+            modelObject.coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity,
+                            coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity_.get());
+      }
+    }
+
+    // Cooling And Charge Mode Capacity Sizing Factor: Required Double
+    const double coolingAndChargeModeCapacitySizingFactor = modelObject.coolingAndChargeModeCapacitySizingFactor();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeCapacitySizingFactor,
+                        coolingAndChargeModeCapacitySizingFactor);
+
+    // Cooling And Charge Mode Rated Storage Charging Capacity
+    if (modelObject.isCoolingAndChargeModeRatedStorageChargingCapacityAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedStorageChargingCapacity, "Autosize");
+    } else {
+      if (boost::optional<double> coolingAndChargeModeRatedStorageChargingCapacity_ =
+            modelObject.coolingAndChargeModeRatedStorageChargingCapacity()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedStorageChargingCapacity,
+                            coolingAndChargeModeRatedStorageChargingCapacity_.get());
+      }
+    }
+
+    // Cooling And Charge Mode Storage Capacity Sizing Factor: Required Double
+    const double coolingAndChargeModeStorageCapacitySizingFactor = modelObject.coolingAndChargeModeStorageCapacitySizingFactor();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageCapacitySizingFactor,
+                        coolingAndChargeModeStorageCapacitySizingFactor);
+
+    // Cooling And Charge Mode Rated Sensible Heat Ratio: Required Double
+    const double coolingAndChargeModeRatedSensibleHeatRatio = modelObject.coolingAndChargeModeRatedSensibleHeatRatio();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedSensibleHeatRatio,
+                        coolingAndChargeModeRatedSensibleHeatRatio);
+
+    // Cooling And Charge Mode Cooling Rated COP: Required Double
+    const double coolingAndChargeModeCoolingRatedCOP = modelObject.coolingAndChargeModeCoolingRatedCOP();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeCoolingRatedCOP, coolingAndChargeModeCoolingRatedCOP);
+
+    // Cooling And Charge Mode Charging Rated COP: Required Double
+    const double coolingAndChargeModeChargingRatedCOP = modelObject.coolingAndChargeModeChargingRatedCOP();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeChargingRatedCOP, coolingAndChargeModeChargingRatedCOP);
+
+    // Cooling And Charge Mode Total Evaporator Cooling Capacity Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve_ =
+          modelObject.coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Total Evaporator Cooling Capacity Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve_ =
+          modelObject.coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Evaporator Energy Input Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve_ =
+          modelObject.coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Evaporator Energy Input Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve_ =
+          modelObject.coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Evaporator Part Load Fraction Correlation Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve_ =
+          modelObject.coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Storage Charge Capacity Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve_ =
+          modelObject.coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Storage Charge Capacity Function of Total Evaporator PLR Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve_ =
+          modelObject.coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Storage Energy Input Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve_ =
+          modelObject.coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Storage Energy Input Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve_ =
+          modelObject.coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Storage Energy Part Load Fraction Correlation Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve_ =
+          modelObject.coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Sensible Heat Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve_ =
+          modelObject.coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling And Charge Mode Sensible Heat Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve_ =
+          modelObject.coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Available: Required Boolean
+    if (coolingAndDischargeModeAvailable) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeAvailable, "Yes");
+    } else {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeAvailable, "No");
+    }
+
+    // Cooling And Discharge Mode Rated Total Evaporator Cooling Capacity
+    if (modelObject.isCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacityAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity, "Autosize");
+    } else {
+      if (boost::optional<double> coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity_ =
+            modelObject.coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity,
+                            coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity_.get());
+      }
+    }
+
+    // Cooling And Discharge Mode Evaporator Capacity Sizing Factor: Required Double
+    const double coolingAndDischargeModeEvaporatorCapacitySizingFactor = modelObject.coolingAndDischargeModeEvaporatorCapacitySizingFactor();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorCapacitySizingFactor,
+                        coolingAndDischargeModeEvaporatorCapacitySizingFactor);
+
+    // Cooling And Discharge Mode Rated Storage Discharging Capacity
+    if (modelObject.isCoolingAndDischargeModeRatedStorageDischargingCapacityAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedStorageDischargingCapacity, "Autosize");
+    } else {
+      if (boost::optional<double> coolingAndDischargeModeRatedStorageDischargingCapacity_ =
+            modelObject.coolingAndDischargeModeRatedStorageDischargingCapacity()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedStorageDischargingCapacity,
+                            coolingAndDischargeModeRatedStorageDischargingCapacity_.get());
+      }
+    }
+
+    // Cooling And Discharge Mode Storage Discharge Capacity Sizing Factor: Required Double
+    const double coolingAndDischargeModeStorageDischargeCapacitySizingFactor =
+      modelObject.coolingAndDischargeModeStorageDischargeCapacitySizingFactor();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacitySizingFactor,
+                        coolingAndDischargeModeStorageDischargeCapacitySizingFactor);
+
+    // Cooling And Discharge Mode Rated Sensible Heat Ratio: Required Double
+    const double coolingAndDischargeModeRatedSensibleHeatRatio = modelObject.coolingAndDischargeModeRatedSensibleHeatRatio();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedSensibleHeatRatio,
+                        coolingAndDischargeModeRatedSensibleHeatRatio);
+
+    // Cooling And Discharge Mode Cooling Rated COP: Required Double
+    const double coolingAndDischargeModeCoolingRatedCOP = modelObject.coolingAndDischargeModeCoolingRatedCOP();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeCoolingRatedCOP,
+                        coolingAndDischargeModeCoolingRatedCOP);
+
+    // Cooling And Discharge Mode Discharging Rated COP: Required Double
+    const double coolingAndDischargeModeDischargingRatedCOP = modelObject.coolingAndDischargeModeDischargingRatedCOP();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeDischargingRatedCOP,
+                        coolingAndDischargeModeDischargingRatedCOP);
+
+    // Cooling And Discharge Mode Total Evaporator Cooling Capacity Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve_ =
+          modelObject.coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Total Evaporator Cooling Capacity Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve_ =
+          modelObject.coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Evaporator Energy Input Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve_ =
+          modelObject.coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Evaporator Energy Input Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve_ =
+          modelObject.coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Evaporator Part Load Fraction Correlation Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve_ =
+          modelObject.coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Storage Discharge Capacity Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve_ =
+          modelObject.coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Storage Discharge Capacity Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve_ =
+          modelObject.coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Storage Discharge Capacity Function of Total Evaporator PLR Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve_ =
+          modelObject.coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Storage Energy Input Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve_ =
+          modelObject.coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Storage Energy Input Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve_ =
+          modelObject.coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ =
+            translateAndMapModelObject(coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Storage Energy Part Load Fraction Correlation Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve_ =
+          modelObject.coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Sensible Heat Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve_ =
+          modelObject.coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Cooling And Discharge Mode Sensible Heat Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve_ =
+          modelObject.coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Charge Only Mode Available: Required Boolean
+    if (chargeOnlyModeAvailable) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeAvailable, "Yes");
+    } else {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeAvailable, "No");
+    }
+
+    // Charge Only Mode Rated Storage Charging Capacity
+    if (modelObject.isChargeOnlyModeRatedStorageChargingCapacityAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeRatedStorageChargingCapacity, "Autosize");
+    } else {
+      if (boost::optional<double> chargeOnlyModeRatedStorageChargingCapacity_ = modelObject.chargeOnlyModeRatedStorageChargingCapacity()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeRatedStorageChargingCapacity,
+                            chargeOnlyModeRatedStorageChargingCapacity_.get());
+      }
+    }
+
+    // Charge Only Mode Capacity Sizing Factor: Required Double
+    const double chargeOnlyModeCapacitySizingFactor = modelObject.chargeOnlyModeCapacitySizingFactor();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeCapacitySizingFactor, chargeOnlyModeCapacitySizingFactor);
+
+    // Charge Only Mode Charging Rated COP: Required Double
+    const double chargeOnlyModeChargingRatedCOP = modelObject.chargeOnlyModeChargingRatedCOP();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeChargingRatedCOP, chargeOnlyModeChargingRatedCOP);
+
+    // Charge Only Mode Storage Charge Capacity Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve_ =
+          modelObject.chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Charge Only Mode Storage Energy Input Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve_ =
+          modelObject.chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Discharge Only Mode Available: Required Boolean
+    if (dischargeOnlyModeAvailable) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeAvailable, "Yes");
+    } else {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeAvailable, "No");
+    }
+
+    // Discharge Only Mode Rated Storage Discharging Capacity
+    if (modelObject.isDischargeOnlyModeRatedStorageDischargingCapacityAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedStorageDischargingCapacity, "Autosize");
+    } else {
+      if (boost::optional<double> dischargeOnlyModeRatedStorageDischargingCapacity_ =
+            modelObject.dischargeOnlyModeRatedStorageDischargingCapacity()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedStorageDischargingCapacity,
+                            dischargeOnlyModeRatedStorageDischargingCapacity_.get());
+      }
+    }
+
+    // Discharge Only Mode Capacity Sizing Factor: Required Double
+    const double dischargeOnlyModeCapacitySizingFactor = modelObject.dischargeOnlyModeCapacitySizingFactor();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeCapacitySizingFactor,
+                        dischargeOnlyModeCapacitySizingFactor);
+
+    // Discharge Only Mode Rated Sensible Heat Ratio: Required Double
+    const double dischargeOnlyModeRatedSensibleHeatRatio = modelObject.dischargeOnlyModeRatedSensibleHeatRatio();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedSensibleHeatRatio,
+                        dischargeOnlyModeRatedSensibleHeatRatio);
+
+    // Discharge Only Mode Rated COP: Required Double
+    const double dischargeOnlyModeRatedCOP = modelObject.dischargeOnlyModeRatedCOP();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedCOP, dischargeOnlyModeRatedCOP);
+
+    // Discharge Only Mode Storage Discharge Capacity Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve_ =
+          modelObject.dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Discharge Only Mode Storage Discharge Capacity Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve_ =
+          modelObject.dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(
+          Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurveName,
+          wo_->nameString());
+      }
+    }
+
+    // Discharge Only Mode Energy Input Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve_ =
+          modelObject.dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Discharge Only Mode Energy Input Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve_ =
+          modelObject.dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Discharge Only Mode Part Load Fraction Correlation Curve Name: Optional Object
+    if (boost::optional<Curve> dischargeOnlyModePartLoadFractionCorrelationCurve_ = modelObject.dischargeOnlyModePartLoadFractionCorrelationCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(dischargeOnlyModePartLoadFractionCorrelationCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModePartLoadFractionCorrelationCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Discharge Only Mode Sensible Heat Ratio Function of Temperature Curve Name: Optional Object
+    if (boost::optional<Curve> dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve_ =
+          modelObject.dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Discharge Only Mode Sensible Heat Ratio Function of Flow Fraction Curve Name: Optional Object
+    if (boost::optional<Curve> dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve_ =
+          modelObject.dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurveName,
+                            wo_->nameString());
+      }
+    }
+
+    // Ancillary Electric Power: boost::optional<double>
+    if (boost::optional<double> ancillaryElectricPower_ = modelObject.ancillaryElectricPower()) {
+      idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::AncillaryElectricPower, ancillaryElectricPower_.get());
+    }
+
+    // Cold Weather Operation Minimum Outdoor Air Temperature: boost::optional<double>
+    if (boost::optional<double> coldWeatherOperationMinimumOutdoorAirTemperature_ = modelObject.coldWeatherOperationMinimumOutdoorAirTemperature()) {
+      idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ColdWeatherOperationMinimumOutdoorAirTemperature,
+                          coldWeatherOperationMinimumOutdoorAirTemperature_.get());
+    }
+
+    // Cold Weather Operation Ancillary Power: boost::optional<double>
+    if (boost::optional<double> coldWeatherOperationAncillaryPower_ = modelObject.coldWeatherOperationAncillaryPower()) {
+      idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ColdWeatherOperationAncillaryPower,
+                          coldWeatherOperationAncillaryPower_.get());
+    }
+
+    // Condenser Air Inlet Node Name: Required Node
+    std::string condenserInletNodeName(modelObject.nameString() + " Condenser Air Inlet Node");
+    // Create an OutdoorAir:NodeList for the condenser inlet conditions to be set directly from weather file
+    IdfObject oaNodeListIdf2(openstudio::IddObjectType::OutdoorAir_NodeList);
+    oaNodeListIdf2.setString(0, condenserInletNodeName);
+    m_idfObjects.push_back(oaNodeListIdf2);
+    idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserAirInletNodeName, condenserInletNodeName);
+
+    // Condenser Air Outlet Node Name: Required Node
+    std::string condenserOutletNodeName(modelObject.nameString() + " Condenser Air Outlet Node");
+    idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserAirOutletNodeName, condenserOutletNodeName);
+
+    // Condenser Design Air Flow Rate
+    if (modelObject.isCondenserDesignAirFlowRateAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserDesignAirFlowRate, "Autosize");
+    } else {
+      if (boost::optional<double> condenserDesignAirFlowRate_ = modelObject.condenserDesignAirFlowRate()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserDesignAirFlowRate, condenserDesignAirFlowRate_.get());
+      }
+    }
+
+    // Condenser Air Flow Sizing Factor: Required Double
+    const double condenserAirFlowSizingFactor = modelObject.condenserAirFlowSizingFactor();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserAirFlowSizingFactor, condenserAirFlowSizingFactor);
+
+    // Condenser Type: Required String
+    const std::string condenserType = modelObject.condenserType();
+    idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserType, condenserType);
+
+    // Evaporative Condenser Effectiveness: Required Double
+    const double evaporativeCondenserEffectiveness = modelObject.evaporativeCondenserEffectiveness();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserEffectiveness, evaporativeCondenserEffectiveness);
+
+    // Evaporative Condenser Pump Rated Power Consumption
+    if (modelObject.isEvaporativeCondenserPumpRatedPowerConsumptionAutosized()) {
+      idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserPumpRatedPowerConsumption, "Autosize");
+    } else {
+      if (boost::optional<double> evaporativeCondenserPumpRatedPowerConsumption_ = modelObject.evaporativeCondenserPumpRatedPowerConsumption()) {
+        idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserPumpRatedPowerConsumption,
+                            evaporativeCondenserPumpRatedPowerConsumption_.get());
+      }
+    }
+
+    // Basin Heater Capacity: Required Double
+    const double basinHeaterCapacity = modelObject.basinHeaterCapacity();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterCapacity, basinHeaterCapacity);
+
+    // Basin Heater Setpoint Temperature: Required Double
+    const double basinHeaterSetpointTemperature = modelObject.basinHeaterSetpointTemperature();
+    idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterSetpointTemperature, basinHeaterSetpointTemperature);
+
+    // Basin Heater Availability Schedule Name: Optional Object
+    if (boost::optional<Schedule> basinHeaterAvailabilitySchedule_ = modelObject.basinHeaterAvailabilitySchedule()) {
+      if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(basinHeaterAvailabilitySchedule_.get())) {
+        idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterAvailabilityScheduleName, wo_->nameString());
+      }
+    }
+
+    // Supply Water Storage Tank Name: Optional Object
+    // if (boost::optional<WaterStorageTank> supplyWaterStorageTank_ = modelObject.supplyWaterStorageTank()) {
+    // if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(supplyWaterStorageTank_.get())) {
+    // idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::SupplyWaterStorageTankName, wo_->nameString());
+    // }
+    // }
+
+    // Condensate Collection Water Storage Tank Name: Optional Object
+    // if (boost::optional<WaterStorageTank> condensateCollectionWaterStorageTank_ = modelObject.condensateCollectionWaterStorageTank()) {
+    // if (boost::optional<IdfObject> wo_ = translateAndMapModelObject(condensateCollectionWaterStorageTank_.get())) {
+    // idfObject.setString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondensateCollectionWaterStorageTankName, wo_->nameString());
+    // }
+    // }
+
+    // Storage Tank Plant Connection Design Flow Rate: boost::optional<double>
+    // if (boost::optional<double> storageTankPlantConnectionDesignFlowRate_ = modelObject.storageTankPlantConnectionDesignFlowRate()) {
+    // idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionDesignFlowRate,
+    // storageTankPlantConnectionDesignFlowRate_.get());
+    // }
+
+    // Storage Tank Plant Connection Heat Transfer Effectiveness: Required Double
+    // const double storageTankPlantConnectionHeatTransferEffectiveness = modelObject.storageTankPlantConnectionHeatTransferEffectiveness();
+    // idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionHeatTransferEffectiveness,
+    // storageTankPlantConnectionHeatTransferEffectiveness);
+
+    // Storage Tank Minimum Operating Limit Fluid Temperature: boost::optional<double>
+    // if (boost::optional<double> storageTankMinimumOperatingLimitFluidTemperature_ = modelObject.storageTankMinimumOperatingLimitFluidTemperature()) {
+    // idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMinimumOperatingLimitFluidTemperature,
+    // storageTankMinimumOperatingLimitFluidTemperature_.get());
+    // }
+
+    // Storage Tank Maximum Operating Limit Fluid Temperature: boost::optional<double>
+    // if (boost::optional<double> storageTankMaximumOperatingLimitFluidTemperature_ = modelObject.storageTankMaximumOperatingLimitFluidTemperature()) {
+    // idfObject.setDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMaximumOperatingLimitFluidTemperature,
+    // storageTankMaximumOperatingLimitFluidTemperature_.get());
+    // }
+
+    return idfObject;
+  }
+
+  boost::optional<IdfObject>
+    ForwardTranslator::translateCoilCoolingDXSingleSpeedThermalStorage(model::CoilCoolingDXSingleSpeedThermalStorage& modelObject) {
+
+    IdfObject coilSystemCoolingDXIdf(IddObjectType::CoilSystem_Cooling_DX);
+
+    m_idfObjects.push_back(coilSystemCoolingDXIdf);
+
+    boost::optional<IdfObject> oIdfObject = translateCoilCoolingDXSingleSpeedThermalStorageWithoutUnitary(modelObject);
+
+    if (!oIdfObject) {
+      return boost::none;
+    }
+
+    IdfObject idfObject = oIdfObject.get();
+
+    OptionalString s;
+
+    s = modelObject.name();
+    if (s) {
+      coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::CoolingCoilObjectType, idfObject.iddObject().name());
+
+      coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::CoolingCoilName, *s);
+
+      coilSystemCoolingDXIdf.setName(*s + " CoilSystem");
+    }
+
+    Schedule sched = modelObject.availabilitySchedule();
+    translateAndMapModelObject(sched);
+
+    coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::AvailabilityScheduleName, sched.name().get());
+
+    OptionalModelObject omo = modelObject.inletModelObject();
+    if (omo) {
+      translateAndMapModelObject(*omo);
+      s = omo->name();
+      if (s) {
+        coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemInletNodeName, *s);
+      }
+    }
+
+    omo = modelObject.outletModelObject();
+    if (omo) {
+      translateAndMapModelObject(*omo);
+      s = omo->name();
+      if (s) {
+        coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemOutletNodeName, *s);
+
+        coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemSensorNodeName, *s);
+      }
+    }
+
+    return coilSystemCoolingDXIdf;
+  }
+
+}  // end namespace energyplus
+}  // end namespace openstudio
diff --git a/src/energyplus/Test/CoilCoolingDXSingleSpeedThermalStorage_GTest.cpp b/src/energyplus/Test/CoilCoolingDXSingleSpeedThermalStorage_GTest.cpp
new file mode 100644
index 00000000000..4f126356b1d
--- /dev/null
+++ b/src/energyplus/Test/CoilCoolingDXSingleSpeedThermalStorage_GTest.cpp
@@ -0,0 +1,642 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2023, 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/CoilCoolingDXSingleSpeedThermalStorage.hpp"
+#include "../../model/CoilCoolingDXSingleSpeedThermalStorage_Impl.hpp"
+
+#include "../../model/ScheduleConstant.hpp"
+#include "../../model/ScheduleConstant_Impl.hpp"
+#include "../../model/CurveBiquadratic.hpp"
+#include "../../model/CurveBiquadratic_Impl.hpp"
+#include "../../model/CurveQuadratic.hpp"
+#include "../../model/CurveQuadratic_Impl.hpp"
+#include "../../model/CurveTriquadratic.hpp"
+#include "../../model/CurveTriquadratic_Impl.hpp"
+
+#include "../../model/AirLoopHVAC.hpp"
+#include "../../model/AirLoopHVACUnitarySystem.hpp"
+#include "../../model/Node.hpp"
+
+#include "../../utilities/idf/Workspace.hpp"
+#include "../../utilities/idf/IdfObject.hpp"
+#include "../../utilities/idf/WorkspaceObject.hpp"
+#include "../../utilities/idf/IdfExtensibleGroup.hpp"
+#include "../../utilities/idf/WorkspaceExtensibleGroup.hpp"
+
+#include <utilities/idd/IddEnums.hxx>
+#include <utilities/idd/IddFactory.hxx>
+#include <utilities/idd/Coil_Cooling_DX_SingleSpeed_ThermalStorage_FieldEnums.hxx>
+#include <utilities/idd/FluidProperties_Name_FieldEnums.hxx>
+#include <utilities/idd/CoilSystem_Cooling_DX_FieldEnums.hxx>
+#include <utilities/idd/AirLoopHVAC_FieldEnums.hxx>
+#include <utilities/idd/BranchList_FieldEnums.hxx>
+#include <utilities/idd/Branch_FieldEnums.hxx>
+#include <utilities/idd/AirLoopHVAC_UnitarySystem_FieldEnums.hxx>
+
+using namespace openstudio::energyplus;
+using namespace openstudio::model;
+using namespace openstudio;
+
+TEST_F(EnergyPlusFixture, ForwardTranslator_CoilCoolingDXSingleSpeedThermalStorage_Unitary) {
+
+  ForwardTranslator ft;
+
+  Model m;
+
+  CoilCoolingDXSingleSpeedThermalStorage coilCoolingDXSingleSpeedThermalStorage(m);
+
+  AirLoopHVACUnitarySystem unitary(m);
+  unitary.setCoolingCoil(coilCoolingDXSingleSpeedThermalStorage);
+  AirLoopHVAC airLoop(m);
+  Node supplyOutletNode = airLoop.supplyOutletNode();
+  unitary.addToNode(supplyOutletNode);
+
+  coilCoolingDXSingleSpeedThermalStorage.setName("My CoilCoolingDXSingleSpeedThermalStorage");
+  ScheduleConstant availabilitySchedule(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setAvailabilitySchedule(availabilitySchedule));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setOperatingModeControlMethod("ScheduledModes"));
+  ScheduleConstant operationModeControlSchedule(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setOperationModeControlSchedule(operationModeControlSchedule));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageType("PropyleneGlycol"));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setGlycolConcentration(25));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeFluidStorageVolume();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setFluidStorageVolume(0.7));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeIceStorageCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setIceStorageCapacity(0.8));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageCapacitySizingFactor(0.9));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient(1.1));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setFluidStorageTankRatingTemperature(1.2));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeRatedEvaporatorAirFlowRate();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setRatedEvaporatorAirFlowRate(1.3));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeAvailable(true));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity(1.7));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeRatedSensibleHeatRatio(0.947));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeRatedCOP(1.9));
+  CurveBiquadratic coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(
+    coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve));
+  CurveQuadratic coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(
+    coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve));
+  CurveBiquadratic coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve(
+    coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve));
+  CurveQuadratic coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve));
+  CurveQuadratic coolingOnlyModePartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(
+    coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModePartLoadFractionCorrelationCurve(coolingOnlyModePartLoadFractionCorrelationCurve));
+  CurveBiquadratic coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(
+    coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve));
+  CurveQuadratic coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(
+    coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeAvailable(true));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity(2.8));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeCapacitySizingFactor(2.9));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingAndChargeModeRatedStorageChargingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeRatedStorageChargingCapacity(3.0));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageCapacitySizingFactor(3.1));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeRatedSensibleHeatRatio(0.97));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeCoolingRatedCOP(3.3));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeChargingRatedCOP(3.4));
+  CurveTriquadratic coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(
+    coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(
+    coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve));
+  CurveTriquadratic coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(
+    coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve));
+  CurveQuadratic coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve(
+    coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve));
+  CurveTriquadratic coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve(
+    coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve(
+    coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve));
+  CurveTriquadratic coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(
+    coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve));
+  CurveQuadratic coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve(
+    coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve));
+  CurveBiquadratic coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve(
+    coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve(
+    coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeAvailable(true));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity(4.8));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeEvaporatorCapacitySizingFactor(4.9));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingAndDischargeModeRatedStorageDischargingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeRatedStorageDischargingCapacity(5.0));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageDischargeCapacitySizingFactor(5.1));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeRatedSensibleHeatRatio(0.981));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeCoolingRatedCOP(5.3));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeDischargingRatedCOP(5.4));
+  CurveTriquadratic coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(
+    coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(
+    coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve));
+  CurveTriquadratic coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(
+    coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve));
+  CurveQuadratic coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve(
+    coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve));
+  CurveTriquadratic coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve(
+    coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve(
+    coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve));
+  CurveQuadratic coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve(
+    coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve));
+  CurveTriquadratic coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(
+    coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve));
+  CurveQuadratic coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve(
+    coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve));
+  CurveBiquadratic coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve(
+    coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve));
+  CurveQuadratic coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve(
+    coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeAvailable(true));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeChargeOnlyModeRatedStorageChargingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeRatedStorageChargingCapacity(6.9));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeCapacitySizingFactor(7.0));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeChargingRatedCOP(7.1));
+  CurveBiquadratic chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve(
+    chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve));
+  CurveBiquadratic chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve(
+    chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeAvailable(true));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeDischargeOnlyModeRatedStorageDischargingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeRatedStorageDischargingCapacity(7.5));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeCapacitySizingFactor(7.6));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeRatedSensibleHeatRatio(0.987));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeRatedCOP(7.8));
+  CurveBiquadratic dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve(
+    dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve));
+  CurveQuadratic dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve(
+    dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve));
+  CurveBiquadratic dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve(
+    dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve));
+  CurveQuadratic dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(
+    dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve));
+  CurveQuadratic dischargeOnlyModePartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(
+    coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModePartLoadFractionCorrelationCurve(dischargeOnlyModePartLoadFractionCorrelationCurve));
+  CurveBiquadratic dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(
+    dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve));
+  CurveQuadratic dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(
+    dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setAncillaryElectricPower(8.6));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setColdWeatherOperationMinimumOutdoorAirTemperature(8.7));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setColdWeatherOperationAncillaryPower(8.8));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeCondenserDesignAirFlowRate();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCondenserDesignAirFlowRate(9.1));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCondenserAirFlowSizingFactor(9.2));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCondenserType("AirCooled"));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setEvaporativeCondenserEffectiveness(0.989));
+  // Autosize
+  // coilCoolingDXSingleSpeedThermalStorage.autosizeEvaporativeCondenserPumpRatedPowerConsumption();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setEvaporativeCondenserPumpRatedPowerConsumption(9.5));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setBasinHeaterCapacity(9.6));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setBasinHeaterSetpointTemperature(11.7));
+  ScheduleConstant basinHeaterAvailabilitySchedule(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setBasinHeaterAvailabilitySchedule(basinHeaterAvailabilitySchedule));
+  // boost::optional<WaterStorageTank> supplyWaterStorageTank(m);
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setSupplyWaterStorageTank(supplyWaterStorageTank));
+  // boost::optional<WaterStorageTank> condensateCollectionWaterStorageTank(m);
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCondensateCollectionWaterStorageTank(condensateCollectionWaterStorageTank));
+  // Node storageTankPlantConnectionInletNodeName(m);
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankPlantConnectionInletNodeName(storageTankPlantConnectionInletNodeName));
+  // Node storageTankPlantConnectionOutletNodeName(m);
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankPlantConnectionOutletNodeName(storageTankPlantConnectionOutletNodeName));
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankPlantConnectionDesignFlowRate(10.3));
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankPlantConnectionHeatTransferEffectiveness(0.99));
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankMinimumOperatingLimitFluidTemperature(10.5));
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankMaximumOperatingLimitFluidTemperature(10.6));
+
+  const Workspace w = ft.translateModel(m);
+
+  const auto idfObjs = w.getObjectsByType(IddObjectType::Coil_Cooling_DX_SingleSpeed_ThermalStorage);
+  ASSERT_EQ(1u, idfObjs.size());
+  const auto& idfObject = idfObjs.front();
+
+  const auto idfUnitarys = w.getObjectsByType(IddObjectType::AirLoopHVAC_UnitarySystem);
+  ASSERT_EQ(1u, idfUnitarys.size());
+  const auto& idfUnitary = idfUnitarys.front();
+
+  EXPECT_EQ(1u, w.getObjectsByType(IddObjectType::FluidProperties_Name).size());
+
+  EXPECT_EQ(availabilitySchedule.nameString(), idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::AvailabilityScheduleName).get());
+  EXPECT_EQ("ScheduledModes", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperatingModeControlMethod).get());
+  EXPECT_EQ(operationModeControlSchedule.nameString(),
+            idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperationModeControlScheduleName).get());
+  EXPECT_EQ("UserDefinedFluidType", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageType).get());
+  boost::optional<WorkspaceObject> woUserDefinedFluidType(
+    idfObject.getTarget(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::UserDefinedFluidType));
+  ASSERT_TRUE(woUserDefinedFluidType);
+  EXPECT_EQ(woUserDefinedFluidType->iddObject().type(), IddObjectType::FluidProperties_Name);
+  EXPECT_EQ("PropyleneGlycol_25", woUserDefinedFluidType->getString(FluidProperties_NameFields::FluidName).get());
+  EXPECT_EQ("Glycol", woUserDefinedFluidType->getString(FluidProperties_NameFields::FluidType).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageVolume).get());
+  EXPECT_EQ(0.7, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageVolume).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::IceStorageCapacity).get());
+  EXPECT_EQ(0.8, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::IceStorageCapacity).get());
+  EXPECT_EQ(0.9, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageCapacitySizingFactor).get());
+  EXPECT_EQ("My CoilCoolingDXSingleSpeedThermalStorage Storage Tank Ambient Temperature Node",
+            idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankAmbientTemperatureNodeName).get());
+  EXPECT_EQ(1.1,
+            idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient).get());
+  EXPECT_EQ(1.2, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageTankRatingTemperature).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::RatedEvaporatorAirFlowRate).get());
+  EXPECT_EQ(1.3, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::RatedEvaporatorAirFlowRate).get());
+
+  // Check that Unitary ends up with CoilCoolingDXSingleSpeedThermalStorage
+  EXPECT_EQ("Coil:Cooling:DX:SingleSpeed:ThermalStorage", idfUnitary.getString(AirLoopHVAC_UnitarySystemFields::CoolingCoilObjectType).get());
+  EXPECT_EQ(idfObject.nameString(), idfUnitary.getString(AirLoopHVAC_UnitarySystemFields::CoolingCoilName).get());
+
+  // Check Node connections
+  EXPECT_NE("", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirInletNodeName).get());
+  EXPECT_NE("", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirOutletNodeName).get());
+  EXPECT_EQ(idfUnitary.getString(AirLoopHVAC_UnitarySystemFields::AirInletNodeName).get(),
+            idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirInletNodeName).get());
+  EXPECT_EQ(idfUnitary.getString(AirLoopHVAC_UnitarySystemFields::AirOutletNodeName).get(),
+            idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirOutletNodeName).get());
+
+  EXPECT_EQ("Yes", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeAvailable).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedTotalEvaporatorCoolingCapacity).get());
+  EXPECT_EQ(1.7, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedTotalEvaporatorCoolingCapacity).get());
+  EXPECT_EQ(0.947, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedSensibleHeatRatio).get());
+  EXPECT_EQ(1.9, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedCOP).get());
+  EXPECT_EQ(
+    coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurveName).get());
+  EXPECT_EQ(
+    coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurveName).get());
+  EXPECT_EQ(coolingOnlyModePartLoadFractionCorrelationCurve.nameString(),
+            idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModePartLoadFractionCorrelationCurveName).get());
+  EXPECT_EQ(
+    coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurveName).get());
+  EXPECT_EQ(
+    coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurveName).get());
+  EXPECT_EQ("Yes", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeAvailable).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity).get());
+  EXPECT_EQ(2.8,
+            idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity).get());
+  EXPECT_EQ(2.9, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeCapacitySizingFactor).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedStorageChargingCapacity).get());
+  EXPECT_EQ(3.0, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedStorageChargingCapacity).get());
+  EXPECT_EQ(3.1, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageCapacitySizingFactor).get());
+  EXPECT_EQ(0.97, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedSensibleHeatRatio).get());
+  EXPECT_EQ(3.3, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeCoolingRatedCOP).get());
+  EXPECT_EQ(3.4, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeChargingRatedCOP).get());
+  EXPECT_EQ(
+    coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurveName).get());
+  EXPECT_EQ(
+    coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurveName).get());
+  EXPECT_EQ(
+    coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ("Yes", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeAvailable).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity).get());
+  EXPECT_EQ(4.8,
+            idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity).get());
+  EXPECT_EQ(4.9, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorCapacitySizingFactor).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedStorageDischargingCapacity).get());
+  EXPECT_EQ(5.0, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedStorageDischargingCapacity).get());
+  EXPECT_EQ(5.1,
+            idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacitySizingFactor).get());
+  EXPECT_EQ(0.981, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedSensibleHeatRatio).get());
+  EXPECT_EQ(5.3, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeCoolingRatedCOP).get());
+  EXPECT_EQ(5.4, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeDischargingRatedCOP).get());
+  EXPECT_EQ(coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve.nameString(),
+            idfObject
+              .getString(
+                Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurveName)
+              .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve.nameString(),
+    idfObject
+      .getString(
+        Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve.nameString(),
+    idfObject
+      .getString(
+        Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject
+      .getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ("Yes", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeAvailable).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeRatedStorageChargingCapacity).get());
+  EXPECT_EQ(6.9, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeRatedStorageChargingCapacity).get());
+  EXPECT_EQ(7.0, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeCapacitySizingFactor).get());
+  EXPECT_EQ(7.1, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeChargingRatedCOP).get());
+  EXPECT_EQ(
+    chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurveName).get());
+  EXPECT_EQ(
+    chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurveName).get());
+  EXPECT_EQ("Yes", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeAvailable).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedStorageDischargingCapacity).get());
+  EXPECT_EQ(7.5, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedStorageDischargingCapacity).get());
+  EXPECT_EQ(7.6, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeCapacitySizingFactor).get());
+  EXPECT_EQ(0.987, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedSensibleHeatRatio).get());
+  EXPECT_EQ(7.8, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedCOP).get());
+  EXPECT_EQ(
+    dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurveName)
+      .get());
+  EXPECT_EQ(
+    dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurveName)
+      .get());
+  EXPECT_EQ(
+    dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurveName).get());
+  EXPECT_EQ(
+    dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurveName).get());
+  EXPECT_EQ(dischargeOnlyModePartLoadFractionCorrelationCurve.nameString(),
+            idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModePartLoadFractionCorrelationCurveName).get());
+  EXPECT_EQ(
+    dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurveName).get());
+  EXPECT_EQ(
+    dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve.nameString(),
+    idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurveName).get());
+  EXPECT_EQ(8.6, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::AncillaryElectricPower).get());
+  EXPECT_EQ(8.7, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ColdWeatherOperationMinimumOutdoorAirTemperature).get());
+  EXPECT_EQ(8.8, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ColdWeatherOperationAncillaryPower).get());
+  EXPECT_EQ("My CoilCoolingDXSingleSpeedThermalStorage Condenser Air Inlet Node",
+            idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserAirInletNodeName).get());
+  EXPECT_EQ("My CoilCoolingDXSingleSpeedThermalStorage Condenser Air Outlet Node",
+            idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserAirOutletNodeName).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserDesignAirFlowRate).get());
+  EXPECT_EQ(9.1, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserDesignAirFlowRate).get());
+  EXPECT_EQ(9.2, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserAirFlowSizingFactor).get());
+  EXPECT_EQ("AirCooled", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserType).get());
+  EXPECT_EQ(0.989, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserEffectiveness).get());
+  // EXPECT_EQ("Autosize", idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserPumpRatedPowerConsumption).get());
+  EXPECT_EQ(9.5, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserPumpRatedPowerConsumption).get());
+  EXPECT_EQ(9.6, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterCapacity).get());
+  EXPECT_EQ(11.7, idfObject.getDouble(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterSetpointTemperature).get());
+  EXPECT_EQ(basinHeaterAvailabilitySchedule.nameString(),
+            idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterAvailabilityScheduleName).get());
+  EXPECT_TRUE(idfObject.isEmpty(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::SupplyWaterStorageTankName));
+  EXPECT_TRUE(idfObject.isEmpty(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondensateCollectionWaterStorageTankName));
+  EXPECT_TRUE(idfObject.isEmpty(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionInletNodeName));
+  EXPECT_TRUE(idfObject.isEmpty(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionOutletNodeName));
+  EXPECT_TRUE(idfObject.isEmpty(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionDesignFlowRate));
+  EXPECT_TRUE(idfObject.isEmpty(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionHeatTransferEffectiveness));
+  EXPECT_TRUE(idfObject.isEmpty(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMinimumOperatingLimitFluidTemperature));
+  EXPECT_TRUE(idfObject.isEmpty(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMaximumOperatingLimitFluidTemperature));
+}
+
+TEST_F(EnergyPlusFixture, ForwardTranslator_CoilCoolingDXSingleSpeedThermalStorage_AirLoopHVAC) {
+
+  ForwardTranslator ft;
+
+  Model m;
+
+  CoilCoolingDXSingleSpeedThermalStorage coilCoolingDXSingleSpeedThermalStorage(m);
+  coilCoolingDXSingleSpeedThermalStorage.setName("My CoilCoolingDXSingleSpeedThermalStorage");
+
+  AirLoopHVAC airLoop(m);
+  Node supplyOutletNode = airLoop.supplyOutletNode();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.addToNode(supplyOutletNode));
+
+  const Workspace w = ft.translateModel(m);
+
+  const auto idfObjs = w.getObjectsByType(IddObjectType::Coil_Cooling_DX_SingleSpeed_ThermalStorage);
+  ASSERT_EQ(1u, idfObjs.size());
+  const auto& idfObject = idfObjs.front();
+
+  const auto idfCoilSyss = w.getObjectsByType(IddObjectType::CoilSystem_Cooling_DX);
+  ASSERT_EQ(1u, idfCoilSyss.size());
+
+  const auto idfAirLoops = w.getObjectsByType(IddObjectType::AirLoopHVAC);
+  ASSERT_EQ(1u, idfAirLoops.size());
+  const auto& idfAirLoop = idfAirLoops.front();
+
+  EXPECT_EQ(idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirInletNodeName).get(),
+            coilCoolingDXSingleSpeedThermalStorage.inletModelObject().get().nameString());
+  EXPECT_EQ(idfObject.getString(Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirOutletNodeName).get(),
+            coilCoolingDXSingleSpeedThermalStorage.outletModelObject().get().nameString());
+
+  WorkspaceObject idf_brlist = idfAirLoop.getTarget(AirLoopHVACFields::BranchListName).get();
+
+  // Should have one branch only
+  ASSERT_EQ(1u, idf_brlist.extensibleGroups().size());
+  auto w_eg = idf_brlist.extensibleGroups()[0].cast<WorkspaceExtensibleGroup>();
+  WorkspaceObject idf_branch = w_eg.getTarget(BranchListExtensibleFields::BranchName).get();
+
+  // There should be only one equipment on the branch
+  ASSERT_EQ(1u, idf_branch.extensibleGroups().size());
+  auto w_eg2 = idf_branch.extensibleGroups()[0].cast<WorkspaceExtensibleGroup>();
+
+  EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(),
+            coilCoolingDXSingleSpeedThermalStorage.inletModelObject().get().nameString());
+  EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentOutletNodeName).get(),
+            coilCoolingDXSingleSpeedThermalStorage.outletModelObject().get().nameString());
+
+  EXPECT_EQ("CoilSystem:Cooling:DX", w_eg2.getString(BranchExtensibleFields::ComponentObjectType).get());
+  auto idf_coilSystem = w_eg2.getTarget(BranchExtensibleFields::ComponentName).get();
+  // CoilSystem:Cooling:DX wrapper needed, it's not inside a unitary
+  EXPECT_EQ(1, w.getObjectsByType(IddObjectType::CoilSystem_Cooling_DX).size());
+
+  EXPECT_EQ("Always On Discrete", idf_coilSystem.getString(CoilSystem_Cooling_DXFields::AvailabilityScheduleName).get());
+  EXPECT_EQ(coilCoolingDXSingleSpeedThermalStorage.inletModelObject().get().nameString(),
+            idf_coilSystem.getString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemInletNodeName).get());
+  EXPECT_EQ(coilCoolingDXSingleSpeedThermalStorage.outletModelObject().get().nameString(),
+            idf_coilSystem.getString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemOutletNodeName).get());
+  EXPECT_EQ(coilCoolingDXSingleSpeedThermalStorage.outletModelObject().get().nameString(),
+            idf_coilSystem.getString(CoilSystem_Cooling_DXFields::DXCoolingCoilSystemSensorNodeName).get());
+  EXPECT_EQ("Coil:Cooling:DX:SingleSpeed:ThermalStorage", idf_coilSystem.getString(CoilSystem_Cooling_DXFields::CoolingCoilObjectType).get());
+  EXPECT_EQ(coilCoolingDXSingleSpeedThermalStorage.nameString(), idf_coilSystem.getString(CoilSystem_Cooling_DXFields::CoolingCoilName).get());
+  EXPECT_EQ(idfObject, idf_coilSystem.getTarget(CoilSystem_Cooling_DXFields::CoolingCoilName).get());
+}
diff --git a/src/model/CMakeLists.txt b/src/model/CMakeLists.txt
index d5f7f454a05..ace62d0374c 100644
--- a/src/model/CMakeLists.txt
+++ b/src/model/CMakeLists.txt
@@ -326,6 +326,9 @@ set(${target_name}_src
   CoilCoolingDXSingleSpeed.hpp
   CoilCoolingDXSingleSpeed_Impl.hpp
   CoilCoolingDXSingleSpeed.cpp
+  CoilCoolingDXSingleSpeedThermalStorage.hpp
+  CoilCoolingDXSingleSpeedThermalStorage_Impl.hpp
+  CoilCoolingDXSingleSpeedThermalStorage.cpp
   CoilCoolingDXTwoSpeed.hpp
   CoilCoolingDXTwoSpeed_Impl.hpp
   CoilCoolingDXTwoSpeed.cpp
@@ -1958,6 +1961,7 @@ set(${target_name}_test_src
   test/CoilCoolingDXCurveFitOperatingMode_GTest.cpp
   test/CoilCoolingDXCurveFitSpeed_GTest.cpp
   test/CoilCoolingDXSingleSpeed_GTest.cpp
+  test/CoilCoolingDXSingleSpeedThermalStorage_GTest.cpp
   test/CoilCoolingDXMultiSpeed_GTest.cpp
   test/CoilCoolingDXTwoSpeed_GTest.cpp
   test/CoilCoolingDXTwoStageWithHumidityControlMode_GTest.cpp
diff --git a/src/model/CoilCoolingDXSingleSpeedThermalStorage.cpp b/src/model/CoilCoolingDXSingleSpeedThermalStorage.cpp
new file mode 100644
index 00000000000..0a1072e9577
--- /dev/null
+++ b/src/model/CoilCoolingDXSingleSpeedThermalStorage.cpp
@@ -0,0 +1,3446 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2023, 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 "CoilCoolingDXSingleSpeedThermalStorage.hpp"
+#include "CoilCoolingDXSingleSpeedThermalStorage_Impl.hpp"
+
+#include "Model.hpp"
+#include "Model_Impl.hpp"
+#include "Schedule.hpp"
+#include "Schedule_Impl.hpp"
+#include "Curve.hpp"
+#include "Curve_Impl.hpp"
+#include "ScheduleTypeLimits.hpp"
+#include "ScheduleTypeRegistry.hpp"
+#include "AirLoopHVACUnitarySystem.hpp"
+#include "AirLoopHVACUnitarySystem_Impl.hpp"
+#include "AirLoopHVACOutdoorAirSystem.hpp"
+#include "AirLoopHVACOutdoorAirSystem_Impl.hpp"
+#include "AirLoopHVACDedicatedOutdoorAirSystem.hpp"
+#include "AirLoopHVACDedicatedOutdoorAirSystem_Impl.hpp"
+#include "Node.hpp"
+#include "Node_Impl.hpp"
+
+#include "../utilities/core/Assert.hpp"
+#include "../utilities/data/DataEnums.hpp"
+
+#include <utilities/idd/IddFactory.hxx>
+#include <utilities/idd/IddEnums.hxx>
+#include <utilities/idd/OS_Coil_Cooling_DX_SingleSpeed_ThermalStorage_FieldEnums.hxx>
+
+namespace openstudio {
+namespace model {
+
+  namespace detail {
+
+    CoilCoolingDXSingleSpeedThermalStorage_Impl::CoilCoolingDXSingleSpeedThermalStorage_Impl(const IdfObject& idfObject, Model_Impl* model,
+                                                                                             bool keepHandle)
+      : StraightComponent_Impl(idfObject, model, keepHandle) {
+      OS_ASSERT(idfObject.iddObject().type() == CoilCoolingDXSingleSpeedThermalStorage::iddObjectType());
+    }
+
+    CoilCoolingDXSingleSpeedThermalStorage_Impl::CoilCoolingDXSingleSpeedThermalStorage_Impl(const openstudio::detail::WorkspaceObject_Impl& other,
+                                                                                             Model_Impl* model, bool keepHandle)
+      : StraightComponent_Impl(other, model, keepHandle) {
+      OS_ASSERT(other.iddObject().type() == CoilCoolingDXSingleSpeedThermalStorage::iddObjectType());
+    }
+
+    CoilCoolingDXSingleSpeedThermalStorage_Impl::CoilCoolingDXSingleSpeedThermalStorage_Impl(const CoilCoolingDXSingleSpeedThermalStorage_Impl& other,
+                                                                                             Model_Impl* model, bool keepHandle)
+      : StraightComponent_Impl(other, model, keepHandle) {}
+
+    const std::vector<std::string>& CoilCoolingDXSingleSpeedThermalStorage_Impl::outputVariableNames() const {
+      static const std::vector<std::string> result{
+        "Cooling Coil Operating Mode Index",
+        "Cooling Coil Total Cooling Rate",
+        "Cooling Coil Total Cooling Energy",
+        "Cooling Coil Sensible Cooling Rate",
+        "Cooling Coil Sensible Cooling Energy",
+        "Cooling Coil Latent Cooling Rate",
+        "Cooling Coil Latent Cooling Energy",
+        "Cooling Coil Electricity Rate",
+        "Cooling Coil Electricity Energy",
+        "Cooling Coil Runtime Fraction",
+        "Cooling Coil Cold Weather Protection Electricity Energy",
+        "Cooling Coil Cold Weather Protection Electricity Rate",
+        "Cooling Coil Thermal Storage Mechanical Heat Transfer Rate",
+        "Cooling Coil Thermal Storage Mechanical Heat Transfer Energy",
+        "Cooling Coil Thermal Storage Ambient Heat Transfer Rate",
+        "Cooling Coil Thermal Storage Ambient Heat Transfer Energy",
+        "Cooling Coil Ice Thermal Storage End Fraction",
+        "Cooling Coil Condenser Inlet Temperature",
+        "Cooling Coil Evaporative Condenser Water Volume",
+        "Cooling Coil Evaporative Condenser Mains Supply Water Volume",
+        "Cooling Coil Evaporative Condenser Pump Electricity Rate",
+        "Cooling Coil Evaporative Condenser Pump Electricity Energy",
+        "Cooling Coil Basin Heater Electricity Rate",
+        "Cooling Coil Basin Heater Electricity Energy",
+        "Cooling Coil Thermal Storage Plant Heat Transfer Rate",
+        "Cooling Coil Thermal Storage Plant Heat Transfer Energy",
+        "Cooling Coil Fluid Thermal Storage End Temperature",
+      };
+      return result;
+    }
+
+    IddObjectType CoilCoolingDXSingleSpeedThermalStorage_Impl::iddObjectType() const {
+      return CoilCoolingDXSingleSpeedThermalStorage::iddObjectType();
+    }
+
+    std::vector<ScheduleTypeKey> CoilCoolingDXSingleSpeedThermalStorage_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
+      std::vector<ScheduleTypeKey> result;
+      const UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
+      if (std::find(fieldIndices.cbegin(), fieldIndices.cend(), OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::AvailabilitySchedule)
+          != fieldIndices.cend()) {
+        result.emplace_back("CoilCoolingDXSingleSpeedThermalStorage", "Availability Schedule");
+      }
+      if (std::find(fieldIndices.cbegin(), fieldIndices.cend(), OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperationModeControlSchedule)
+          != fieldIndices.cend()) {
+        result.emplace_back("CoilCoolingDXSingleSpeedThermalStorage", "Operation Mode Control Schedule");
+      }
+      if (std::find(fieldIndices.cbegin(), fieldIndices.cend(), OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterAvailabilitySchedule)
+          != fieldIndices.cend()) {
+        result.emplace_back("CoilCoolingDXSingleSpeedThermalStorage", "Basin Heater Availability Schedule");
+      }
+      return result;
+    }
+
+    unsigned CoilCoolingDXSingleSpeedThermalStorage_Impl::inletPort() const {
+      return OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirInletNode;
+    }
+
+    unsigned CoilCoolingDXSingleSpeedThermalStorage_Impl::outletPort() const {
+      return OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporatorAirOutletNode;
+    }
+
+    boost::optional<HVACComponent> CoilCoolingDXSingleSpeedThermalStorage_Impl::containingHVACComponent() const {
+      // AirLoopHVACUnitarySystem
+      std::vector<AirLoopHVACUnitarySystem> airLoopHVACUnitarySystems = this->model().getConcreteModelObjects<AirLoopHVACUnitarySystem>();
+
+      for (const auto& airLoopHVACUnitarySystem : airLoopHVACUnitarySystems) {
+        if (boost::optional<HVACComponent> coolingCoil = airLoopHVACUnitarySystem.coolingCoil()) {
+          if (coolingCoil->handle() == this->handle()) {
+            return airLoopHVACUnitarySystem;
+          }
+        }
+      }
+
+      return boost::none;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::addToNode(Node& node) {
+      if (boost::optional<AirLoopHVAC> airLoop = node.airLoopHVAC()) {
+        if (!airLoop->demandComponent(node.handle())) {
+          return StraightComponent_Impl::addToNode(node);
+        }
+      } else if (boost::optional<AirLoopHVACOutdoorAirSystem> oas = node.airLoopHVACOutdoorAirSystem()) {
+        if (oas->airLoopHVACDedicatedOutdoorAirSystem()) {
+          return StraightComponent_Impl::addToNode(node);
+        }
+      }
+
+      return false;
+    }
+
+    std::vector<ModelObject> CoilCoolingDXSingleSpeedThermalStorage_Impl::children() const {
+      std::vector<ModelObject> result;
+
+      boost::optional<ModelObject> curve;
+
+      curve = coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingOnlyModePartLoadFractionCorrelationCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = dischargeOnlyModePartLoadFractionCorrelationCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      curve = dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+      if (curve) {
+        result.push_back(curve.get());
+      }
+
+      return result;
+    }
+
+    ComponentType CoilCoolingDXSingleSpeedThermalStorage_Impl::componentType() const {
+      return ComponentType::Cooling;
+    }
+
+    std::vector<FuelType> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingFuelTypes() const {
+      return {FuelType::Electricity};
+    }
+
+    std::vector<FuelType> CoilCoolingDXSingleSpeedThermalStorage_Impl::heatingFuelTypes() const {
+      return {};
+    }
+
+    std::vector<AppGFuelType> CoilCoolingDXSingleSpeedThermalStorage_Impl::appGHeatingFuelTypes() const {
+      return {};
+    }
+
+    Schedule CoilCoolingDXSingleSpeedThermalStorage_Impl::availabilitySchedule() const {
+      boost::optional<Schedule> value = optionalAvailabilitySchedule();
+      if (!value) {
+        LOG_AND_THROW(briefDescription() << " does not have an Availability Schedule attached.");
+      }
+      return value.get();
+    }
+
+    std::string CoilCoolingDXSingleSpeedThermalStorage_Impl::operatingModeControlMethod() const {
+      boost::optional<std::string> value = getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperatingModeControlMethod, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Schedule> CoilCoolingDXSingleSpeedThermalStorage_Impl::operationModeControlSchedule() const {
+      return getObject<ModelObject>().getModelObjectTarget<Schedule>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperationModeControlSchedule);
+    }
+
+    std::string CoilCoolingDXSingleSpeedThermalStorage_Impl::storageType() const {
+      boost::optional<std::string> value = getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageType, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    int CoilCoolingDXSingleSpeedThermalStorage_Impl::glycolConcentration() const {
+      boost::optional<int> value = getInt(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::GlycolConcentration, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::fluidStorageVolume() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageVolume, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isFluidStorageVolumeAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageVolume, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedFluidStorageVolume() {
+      return getAutosizedValue("Fluid Storage Volume", "m3");
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::iceStorageCapacity() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::IceStorageCapacity, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isIceStorageCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::IceStorageCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedIceStorageCapacity() {
+      return getAutosizedValue("Ice Storage Capacity", "GJ");
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::storageCapacitySizingFactor() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageCapacitySizingFactor, true);
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient() const {
+      boost::optional<double> value =
+        getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::fluidStorageTankRatingTemperature() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageTankRatingTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::ratedEvaporatorAirFlowRate() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::RatedEvaporatorAirFlowRate, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isRatedEvaporatorAirFlowRateAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::RatedEvaporatorAirFlowRate, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedRatedEvaporatorAirFlowRate() {
+      return getAutosizedValue("Rated Evaporator Air Flow Rate", "m3/s");
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeAvailable() const {
+      return getBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeAvailable);
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeRatedTotalEvaporatorCoolingCapacity() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedTotalEvaporatorCoolingCapacity, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isCoolingOnlyModeRatedTotalEvaporatorCoolingCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value =
+        getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedTotalEvaporatorCoolingCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity() {
+      return getAutosizedValue("Cooling Only Mode Rated Total Evaporator Cooling Capacity", "W");
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeRatedSensibleHeatRatio() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedSensibleHeatRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeRatedCOP() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedCOP, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModePartLoadFractionCorrelationCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModePartLoadFractionCorrelationCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeAvailable() const {
+      return getBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeAvailable);
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value =
+        getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity() {
+      return getAutosizedValue("Cooling And Charge Mode Rated Total Evaporator Cooling Capacity", "W");
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeCapacitySizingFactor() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeCapacitySizingFactor, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeRatedStorageChargingCapacity() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedStorageChargingCapacity, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isCoolingAndChargeModeRatedStorageChargingCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value =
+        getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedStorageChargingCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedCoolingAndChargeModeRatedStorageChargingCapacity() {
+      return getAutosizedValue("Cooling And Charge Mode Rated Storage Charging Capacity", "W");
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeStorageCapacitySizingFactor() const {
+      boost::optional<double> value =
+        getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageCapacitySizingFactor, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeRatedSensibleHeatRatio() const {
+      boost::optional<double> value =
+        getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedSensibleHeatRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeCoolingRatedCOP() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeCoolingRatedCOP, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeChargingRatedCOP() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeChargingRatedCOP, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeAvailable() const {
+      return getBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeAvailable);
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value =
+        getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity() {
+      return getAutosizedValue("Cooling And Discharge Mode Rated Total Evaporator Cooling Capacity", "W");
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeEvaporatorCapacitySizingFactor() const {
+      boost::optional<double> value =
+        getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorCapacitySizingFactor, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeRatedStorageDischargingCapacity() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedStorageDischargingCapacity, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isCoolingAndDischargeModeRatedStorageDischargingCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value =
+        getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedStorageDischargingCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedCoolingAndDischargeModeRatedStorageDischargingCapacity() {
+      return getAutosizedValue("Cooling And Discharge Mode Rated Storage Discharging Capacity", "W");
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeStorageDischargeCapacitySizingFactor() const {
+      boost::optional<double> value =
+        getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacitySizingFactor, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeRatedSensibleHeatRatio() const {
+      boost::optional<double> value =
+        getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedSensibleHeatRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeCoolingRatedCOP() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeCoolingRatedCOP, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeDischargingRatedCOP() const {
+      boost::optional<double> value =
+        getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeDischargingRatedCOP, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve>
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::chargeOnlyModeAvailable() const {
+      return getBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeAvailable);
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::chargeOnlyModeRatedStorageChargingCapacity() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeRatedStorageChargingCapacity, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isChargeOnlyModeRatedStorageChargingCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value =
+        getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeRatedStorageChargingCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedChargeOnlyModeRatedStorageChargingCapacity() {
+      return getAutosizedValue("Charge Only Mode Rated Storage Charging Capacity", "W");
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::chargeOnlyModeCapacitySizingFactor() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeCapacitySizingFactor, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::chargeOnlyModeChargingRatedCOP() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeChargingRatedCOP, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeAvailable() const {
+      return getBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeAvailable);
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeRatedStorageDischargingCapacity() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedStorageDischargingCapacity, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isDischargeOnlyModeRatedStorageDischargingCapacityAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value =
+        getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedStorageDischargingCapacity, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedDischargeOnlyModeRatedStorageDischargingCapacity() {
+      return getAutosizedValue("Discharge Only Mode Rated Storage Discharging Capacity", "W");
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeCapacitySizingFactor() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeCapacitySizingFactor, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeRatedSensibleHeatRatio() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedSensibleHeatRatio, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeRatedCOP() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedCOP, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModePartLoadFractionCorrelationCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModePartLoadFractionCorrelationCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve);
+    }
+
+    boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage_Impl::dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() const {
+      return getObject<ModelObject>().getModelObjectTarget<Curve>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve);
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::ancillaryElectricPower() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::AncillaryElectricPower, true);
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::coldWeatherOperationMinimumOutdoorAirTemperature() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ColdWeatherOperationMinimumOutdoorAirTemperature, true);
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::coldWeatherOperationAncillaryPower() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ColdWeatherOperationAncillaryPower, true);
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::condenserDesignAirFlowRate() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserDesignAirFlowRate, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isCondenserDesignAirFlowRateAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserDesignAirFlowRate, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedCondenserDesignAirFlowRate() {
+      return getAutosizedValue("Condenser Air Flow Rate", "W");
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::condenserAirFlowSizingFactor() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserAirFlowSizingFactor, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    std::string CoilCoolingDXSingleSpeedThermalStorage_Impl::condenserType() const {
+      boost::optional<std::string> value = getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserType, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::evaporativeCondenserEffectiveness() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserEffectiveness, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::evaporativeCondenserPumpRatedPowerConsumption() const {
+      return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserPumpRatedPowerConsumption, true);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value =
+        getString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserPumpRatedPowerConsumption, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
+    boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizedEvaporativeCondenserPumpRatedPowerConsumption() {
+      return getAutosizedValue("Evaporative Condenser Pump Rated Power Consumption", "W");
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::basinHeaterCapacity() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterCapacity, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    double CoilCoolingDXSingleSpeedThermalStorage_Impl::basinHeaterSetpointTemperature() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterSetpointTemperature, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    boost::optional<Schedule> CoilCoolingDXSingleSpeedThermalStorage_Impl::basinHeaterAvailabilitySchedule() const {
+      return getObject<ModelObject>().getModelObjectTarget<Schedule>(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterAvailabilitySchedule);
+    }
+
+    // boost::optional<WaterStorageTank> CoilCoolingDXSingleSpeedThermalStorage_Impl::supplyWaterStorageTank() const {
+    // return getObject<ModelObject>().getModelObjectTarget<WaterStorageTank>(
+    // OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::SupplyWaterStorageTank);
+    // }
+
+    // boost::optional<WaterStorageTank> CoilCoolingDXSingleSpeedThermalStorage_Impl::condensateCollectionWaterStorageTank() const {
+    // return getObject<ModelObject>().getModelObjectTarget<WaterStorageTank>(
+    // OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondensateCollectionWaterStorageTank);
+    // }
+
+    // boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::storageTankPlantConnectionDesignFlowRate() const {
+    // return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionDesignFlowRate, true);
+    // }
+
+    // double CoilCoolingDXSingleSpeedThermalStorage_Impl::storageTankPlantConnectionHeatTransferEffectiveness() const {
+    // boost::optional<double> value =
+    // getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionHeatTransferEffectiveness, true);
+    // OS_ASSERT(value);
+    // return value.get();
+    // }
+
+    // boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::storageTankMinimumOperatingLimitFluidTemperature() const {
+    // return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMinimumOperatingLimitFluidTemperature, true);
+    // }
+
+    // boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage_Impl::storageTankMaximumOperatingLimitFluidTemperature() const {
+    // return getDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMaximumOperatingLimitFluidTemperature, true);
+    // }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setAvailabilitySchedule(Schedule& schedule) {
+      const bool result = setSchedule(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::AvailabilitySchedule,
+                                      "CoilCoolingDXSingleSpeedThermalStorage", "Availability Schedule", schedule);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setOperatingModeControlMethod(const std::string& operatingModeControlMethod) {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperatingModeControlMethod, operatingModeControlMethod);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setOperationModeControlSchedule(Schedule& schedule) {
+      const bool result = setSchedule(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperationModeControlSchedule,
+                                      "CoilCoolingDXSingleSpeedThermalStorage", "Operation Mode Control Schedule", schedule);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetOperationModeControlSchedule() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperationModeControlSchedule, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setStorageType(const std::string& storageType) {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageType, storageType);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setGlycolConcentration(int glycolConcentration) {
+      const bool result = setInt(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::GlycolConcentration, glycolConcentration);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setFluidStorageVolume(double fluidStorageVolume) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageVolume, fluidStorageVolume);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetFluidStorageVolume() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageVolume, "");
+      OS_ASSERT(result);
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeFluidStorageVolume() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageVolume, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setIceStorageCapacity(double iceStorageCapacity) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::IceStorageCapacity, iceStorageCapacity);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeIceStorageCapacity() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::IceStorageCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setStorageCapacitySizingFactor(double storageCapacitySizingFactor) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageCapacitySizingFactor, storageCapacitySizingFactor);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setStorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient(
+      double storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient,
+                                    storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setFluidStorageTankRatingTemperature(double fluidStorageTankRatingTemperature) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::FluidStorageTankRatingTemperature, fluidStorageTankRatingTemperature);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setRatedEvaporatorAirFlowRate(double ratedEvaporatorAirFlowRate) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::RatedEvaporatorAirFlowRate, ratedEvaporatorAirFlowRate);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeRatedEvaporatorAirFlowRate() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::RatedEvaporatorAirFlowRate, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeAvailable(bool coolingOnlyModeAvailable) {
+      return setBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeAvailable, coolingOnlyModeAvailable);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity(
+      double coolingOnlyModeRatedTotalEvaporatorCoolingCapacity) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedTotalEvaporatorCoolingCapacity,
+                                    coolingOnlyModeRatedTotalEvaporatorCoolingCapacity);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedTotalEvaporatorCoolingCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeRatedSensibleHeatRatio(double coolingOnlyModeRatedSensibleHeatRatio) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedSensibleHeatRatio, coolingOnlyModeRatedSensibleHeatRatio);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeRatedCOP(double coolingOnlyModeRatedCOP) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeRatedCOP, coolingOnlyModeRatedCOP);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModePartLoadFractionCorrelationCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModePartLoadFractionCorrelationCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingOnlyModePartLoadFractionCorrelationCurve() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModePartLoadFractionCorrelationCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeAvailable(bool coolingAndChargeModeAvailable) {
+      return setBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeAvailable, coolingAndChargeModeAvailable);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity(
+      double coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity,
+                                    coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeCapacitySizingFactor(double coolingAndChargeModeCapacitySizingFactor) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeCapacitySizingFactor,
+                                    coolingAndChargeModeCapacitySizingFactor);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeRatedStorageChargingCapacity(
+      double coolingAndChargeModeRatedStorageChargingCapacity) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedStorageChargingCapacity,
+                                    coolingAndChargeModeRatedStorageChargingCapacity);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeCoolingAndChargeModeRatedStorageChargingCapacity() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedStorageChargingCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeStorageCapacitySizingFactor(
+      double coolingAndChargeModeStorageCapacitySizingFactor) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageCapacitySizingFactor,
+                                    coolingAndChargeModeStorageCapacitySizingFactor);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeRatedSensibleHeatRatio(double coolingAndChargeModeRatedSensibleHeatRatio) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeRatedSensibleHeatRatio,
+                                    coolingAndChargeModeRatedSensibleHeatRatio);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeCoolingRatedCOP(double coolingAndChargeModeCoolingRatedCOP) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeCoolingRatedCOP, coolingAndChargeModeCoolingRatedCOP);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeChargingRatedCOP(double coolingAndChargeModeChargingRatedCOP) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeChargingRatedCOP, coolingAndChargeModeChargingRatedCOP);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(
+      const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() {
+      const bool result = setString(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(
+      const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() {
+      const bool result = setString(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve() {
+      const bool result = setString(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeAvailable(bool coolingAndDischargeModeAvailable) {
+      return setBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeAvailable,
+                                  coolingAndDischargeModeAvailable);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity(
+      double coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity,
+                                    coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeEvaporatorCapacitySizingFactor(
+      double coolingAndDischargeModeEvaporatorCapacitySizingFactor) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorCapacitySizingFactor,
+                                    coolingAndDischargeModeEvaporatorCapacitySizingFactor);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeRatedStorageDischargingCapacity(
+      double coolingAndDischargeModeRatedStorageDischargingCapacity) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedStorageDischargingCapacity,
+                                    coolingAndDischargeModeRatedStorageDischargingCapacity);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeCoolingAndDischargeModeRatedStorageDischargingCapacity() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedStorageDischargingCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeStorageDischargeCapacitySizingFactor(
+      double coolingAndDischargeModeStorageDischargeCapacitySizingFactor) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacitySizingFactor,
+                                    coolingAndDischargeModeStorageDischargeCapacitySizingFactor);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeRatedSensibleHeatRatio(
+      double coolingAndDischargeModeRatedSensibleHeatRatio) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeRatedSensibleHeatRatio,
+                                    coolingAndDischargeModeRatedSensibleHeatRatio);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeCoolingRatedCOP(double coolingAndDischargeModeCoolingRatedCOP) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeCoolingRatedCOP,
+                                    coolingAndDischargeModeCoolingRatedCOP);
+      return result;
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeDischargingRatedCOP(double coolingAndDischargeModeDischargingRatedCOP) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeDischargingRatedCOP,
+                                    coolingAndDischargeModeDischargingRatedCOP);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(
+      const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve,
+        Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() {
+      const bool result = setString(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(
+      const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve,
+        Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() {
+      const bool result = setString(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(
+      const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() {
+      const bool result = setString(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(
+      const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() {
+      const bool result = setString(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve() {
+      const bool result = setString(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve(
+      const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve,
+        Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve() {
+      const bool result = setString(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve,
+                   Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setChargeOnlyModeAvailable(bool chargeOnlyModeAvailable) {
+      return setBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeAvailable, chargeOnlyModeAvailable);
+    }
+
+    bool
+      CoilCoolingDXSingleSpeedThermalStorage_Impl::setChargeOnlyModeRatedStorageChargingCapacity(double chargeOnlyModeRatedStorageChargingCapacity) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeRatedStorageChargingCapacity,
+                                    chargeOnlyModeRatedStorageChargingCapacity);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeChargeOnlyModeRatedStorageChargingCapacity() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeRatedStorageChargingCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setChargeOnlyModeCapacitySizingFactor(double chargeOnlyModeCapacitySizingFactor) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeCapacitySizingFactor, chargeOnlyModeCapacitySizingFactor);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setChargeOnlyModeChargingRatedCOP(double chargeOnlyModeChargingRatedCOP) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeChargingRatedCOP, chargeOnlyModeChargingRatedCOP);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeAvailable(bool dischargeOnlyModeAvailable) {
+      return setBooleanFieldValue(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeAvailable, dischargeOnlyModeAvailable);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeRatedStorageDischargingCapacity(
+      double dischargeOnlyModeRatedStorageDischargingCapacity) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedStorageDischargingCapacity,
+                                    dischargeOnlyModeRatedStorageDischargingCapacity);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeDischargeOnlyModeRatedStorageDischargingCapacity() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedStorageDischargingCapacity, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeCapacitySizingFactor(double dischargeOnlyModeCapacitySizingFactor) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeCapacitySizingFactor, dischargeOnlyModeCapacitySizingFactor);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeRatedSensibleHeatRatio(double dischargeOnlyModeRatedSensibleHeatRatio) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedSensibleHeatRatio,
+                                    dischargeOnlyModeRatedSensibleHeatRatio);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeRatedCOP(double dischargeOnlyModeRatedCOP) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeRatedCOP, dischargeOnlyModeRatedCOP);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModePartLoadFractionCorrelationCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModePartLoadFractionCorrelationCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetDischargeOnlyModePartLoadFractionCorrelationCurve() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModePartLoadFractionCorrelationCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve) {
+      const bool result =
+        setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+      const bool result = setPointer(
+        OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve, Curve.handle());
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() {
+      const bool result =
+        setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::DischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setAncillaryElectricPower(double ancillaryElectricPower) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::AncillaryElectricPower, ancillaryElectricPower);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setColdWeatherOperationMinimumOutdoorAirTemperature(
+      double coldWeatherOperationMinimumOutdoorAirTemperature) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ColdWeatherOperationMinimumOutdoorAirTemperature,
+                                    coldWeatherOperationMinimumOutdoorAirTemperature);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetColdWeatherOperationMinimumOutdoorAirTemperature() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ColdWeatherOperationMinimumOutdoorAirTemperature, "");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setColdWeatherOperationAncillaryPower(double coldWeatherOperationAncillaryPower) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::ColdWeatherOperationAncillaryPower, coldWeatherOperationAncillaryPower);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCondenserDesignAirFlowRate(double condenserDesignAirFlowRate) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserDesignAirFlowRate, condenserDesignAirFlowRate);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeCondenserDesignAirFlowRate() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserDesignAirFlowRate, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCondenserAirFlowSizingFactor(double condenserAirFlowSizingFactor) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserAirFlowSizingFactor, condenserAirFlowSizingFactor);
+      OS_ASSERT(result);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCondenserType(const std::string& condenserType) {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserType, condenserType);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setEvaporativeCondenserEffectiveness(double evaporativeCondenserEffectiveness) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserEffectiveness, evaporativeCondenserEffectiveness);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setEvaporativeCondenserPumpRatedPowerConsumption(
+      double evaporativeCondenserPumpRatedPowerConsumption) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserPumpRatedPowerConsumption,
+                                    evaporativeCondenserPumpRatedPowerConsumption);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosizeEvaporativeCondenserPumpRatedPowerConsumption() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::EvaporativeCondenserPumpRatedPowerConsumption, "autosize");
+      OS_ASSERT(result);
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setBasinHeaterCapacity(double basinHeaterCapacity) {
+      const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterCapacity, basinHeaterCapacity);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setBasinHeaterSetpointTemperature(double basinHeaterSetpointTemperature) {
+      const bool result =
+        setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterSetpointTemperature, basinHeaterSetpointTemperature);
+      return result;
+    }
+
+    bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setBasinHeaterAvailabilitySchedule(Schedule& schedule) {
+      const bool result = setSchedule(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterAvailabilitySchedule,
+                                      "CoilCoolingDXSingleSpeedThermalStorage", "Basin Heater Availability Schedule", schedule);
+      return result;
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetBasinHeaterAvailabilitySchedule() {
+      const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::BasinHeaterAvailabilitySchedule, "");
+      OS_ASSERT(result);
+    }
+
+    // bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setSupplyWaterStorageTank(const WaterStorageTank& waterStorageTank) {
+    // const bool result = setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::SupplyWaterStorageTank, waterStorageTank.handle());
+    // return result;
+    // }
+
+    // void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetSupplyWaterStorageTank() {
+    // const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::SupplyWaterStorageTank, "");
+    // OS_ASSERT(result);
+    // }
+
+    // bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setCondensateCollectionWaterStorageTank(const WaterStorageTank& waterStorageTank) {
+    // const bool result =
+    // setPointer(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondensateCollectionWaterStorageTank, waterStorageTank.handle());
+    // return result;
+    // }
+
+    // void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetCondensateCollectionWaterStorageTank() {
+    // const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondensateCollectionWaterStorageTank, "");
+    // OS_ASSERT(result);
+    // }
+
+    // bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setStorageTankPlantConnectionDesignFlowRate(double storageTankPlantConnectionDesignFlowRate) {
+    // const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionDesignFlowRate,
+    // storageTankPlantConnectionDesignFlowRate);
+    // return result;
+    // }
+
+    // void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetStorageTankPlantConnectionDesignFlowRate() {
+    // const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionDesignFlowRate, "");
+    // OS_ASSERT(result);
+    // }
+
+    // bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setStorageTankPlantConnectionHeatTransferEffectiveness(
+    // double storageTankPlantConnectionHeatTransferEffectiveness) {
+    // const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankPlantConnectionHeatTransferEffectiveness,
+    // storageTankPlantConnectionHeatTransferEffectiveness);
+    // return result;
+    // }
+
+    // bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setStorageTankMinimumOperatingLimitFluidTemperature(
+    // double storageTankMinimumOperatingLimitFluidTemperature) {
+    // const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMinimumOperatingLimitFluidTemperature,
+    // storageTankMinimumOperatingLimitFluidTemperature);
+    // OS_ASSERT(result);
+    // return result;
+    // }
+
+    // void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetStorageTankMinimumOperatingLimitFluidTemperature() {
+    // const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMinimumOperatingLimitFluidTemperature, "");
+    // OS_ASSERT(result);
+    // }
+
+    // bool CoilCoolingDXSingleSpeedThermalStorage_Impl::setStorageTankMaximumOperatingLimitFluidTemperature(
+    // double storageTankMaximumOperatingLimitFluidTemperature) {
+    // const bool result = setDouble(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMaximumOperatingLimitFluidTemperature,
+    // storageTankMaximumOperatingLimitFluidTemperature);
+    // OS_ASSERT(result);
+    // return result;
+    // }
+
+    // void CoilCoolingDXSingleSpeedThermalStorage_Impl::resetStorageTankMaximumOperatingLimitFluidTemperature() {
+    // const bool result = setString(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageTankMaximumOperatingLimitFluidTemperature, "");
+    // OS_ASSERT(result);
+    // }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::autosize() {
+      autosizeRatedEvaporatorAirFlowRate();
+      autosizeCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+      autosizeEvaporativeCondenserPumpRatedPowerConsumption();
+    }
+
+    void CoilCoolingDXSingleSpeedThermalStorage_Impl::applySizingValues() {
+      if (boost::optional<double> val_ = autosizedRatedEvaporatorAirFlowRate()) {
+        setRatedEvaporatorAirFlowRate(val_.get());
+      }
+
+      if (boost::optional<double> val_ = autosizedCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity()) {
+        setCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity(val_.get());
+      }
+
+      if (boost::optional<double> val_ = autosizedEvaporativeCondenserPumpRatedPowerConsumption()) {
+        setEvaporativeCondenserPumpRatedPowerConsumption(val_.get());
+      }
+    }
+
+    boost::optional<Schedule> CoilCoolingDXSingleSpeedThermalStorage_Impl::optionalAvailabilitySchedule() const {
+      return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::AvailabilitySchedule);
+    }
+
+  }  // namespace detail
+
+  CoilCoolingDXSingleSpeedThermalStorage::CoilCoolingDXSingleSpeedThermalStorage(const Model& model)
+    : StraightComponent(CoilCoolingDXSingleSpeedThermalStorage::iddObjectType(), model) {
+    OS_ASSERT(getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>());
+
+    bool ok = true;
+    auto schedule_on = model.alwaysOnDiscreteSchedule();
+    ok = setAvailabilitySchedule(schedule_on);
+    OS_ASSERT(ok);
+    ok = setOperatingModeControlMethod("ScheduledModes");  // intentionally NOT setting an operation mode control schedule
+    OS_ASSERT(ok);
+    ok = setStorageType("Ice");  // RetailPackagedTESCoil.idf
+    OS_ASSERT(ok);
+    ok = setGlycolConcentration(0);
+    OS_ASSERT(ok);
+    autosizeFluidStorageVolume();
+    autosizeIceStorageCapacity();
+    ok = setStorageCapacitySizingFactor(6.0);  // RetailPackagedTESCoil.idf
+    OS_ASSERT(ok);
+    ok = setStorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient(7.913);  // RetailPackagedTESCoil.idf
+    OS_ASSERT(ok);
+    ok = setFluidStorageTankRatingTemperature(26.7);
+    OS_ASSERT(ok);
+    autosizeRatedEvaporatorAirFlowRate();
+
+    // Cooling Only Mode
+    ok = setCoolingOnlyModeAvailable(false);
+    OS_ASSERT(ok);
+    autosizeCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+    ok = setCoolingOnlyModeRatedSensibleHeatRatio(0.7);  // IDD default
+    OS_ASSERT(ok);
+    ok = setCoolingOnlyModeRatedCOP(3.0);  // IDD default
+    OS_ASSERT(ok);
+
+    // Cooling And Charge Mode
+    ok = setCoolingAndChargeModeAvailable(false);
+    OS_ASSERT(ok);
+    autosizeCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+    ok = setCoolingAndChargeModeCapacitySizingFactor(0.5);  // IDD default
+    OS_ASSERT(ok);
+    autosizeCoolingAndChargeModeRatedStorageChargingCapacity();
+    ok = setCoolingAndChargeModeStorageCapacitySizingFactor(0.5);  // IDD default
+    OS_ASSERT(ok);
+    ok = setCoolingAndChargeModeRatedSensibleHeatRatio(0.7);  // IDD default
+    OS_ASSERT(ok);
+    ok = setCoolingAndChargeModeCoolingRatedCOP(3.0);  // IDD default
+    OS_ASSERT(ok);
+    ok = setCoolingAndChargeModeChargingRatedCOP(3.0);  // IDD default
+    OS_ASSERT(ok);
+
+    // Cooling And Discharge Mode
+    ok = setCoolingAndDischargeModeAvailable(false);
+    OS_ASSERT(ok);
+    autosizeCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+    ok = setCoolingAndDischargeModeEvaporatorCapacitySizingFactor(1.0);  // IDD default
+    OS_ASSERT(ok);
+    autosizeCoolingAndDischargeModeRatedStorageDischargingCapacity();
+    ok = setCoolingAndDischargeModeStorageDischargeCapacitySizingFactor(1.0);  // IDD default
+    OS_ASSERT(ok);
+    ok = setCoolingAndDischargeModeRatedSensibleHeatRatio(0.7);  // IDD default
+    OS_ASSERT(ok);
+    ok = setCoolingAndDischargeModeCoolingRatedCOP(3.0);  // IDD default
+    OS_ASSERT(ok);
+    ok = setCoolingAndDischargeModeDischargingRatedCOP(3.0);  // IDD default
+    OS_ASSERT(ok);
+
+    // Charge Only Mode
+    ok = setChargeOnlyModeAvailable(false);
+    OS_ASSERT(ok);
+    autosizeChargeOnlyModeRatedStorageChargingCapacity();
+    ok = setChargeOnlyModeCapacitySizingFactor(1.0);  // IDD default
+    OS_ASSERT(ok);
+    ok = setChargeOnlyModeChargingRatedCOP(3.0);  // IDD default
+    OS_ASSERT(ok);
+
+    // Discharge Only Mode
+    ok = setDischargeOnlyModeAvailable(false);
+    OS_ASSERT(ok);
+    autosizeDischargeOnlyModeRatedStorageDischargingCapacity();
+    ok = setDischargeOnlyModeCapacitySizingFactor(1.0);  // IDD default
+    OS_ASSERT(ok);
+    ok = setDischargeOnlyModeRatedSensibleHeatRatio(0.7);  // Assumed; default missing in IDD
+    OS_ASSERT(ok);
+    ok = setDischargeOnlyModeRatedCOP(3.0);  // IDD default
+    OS_ASSERT(ok);
+
+    ok = setAncillaryElectricPower(0.0);
+    OS_ASSERT(ok);
+    ok = setColdWeatherOperationAncillaryPower(0.0);
+    OS_ASSERT(ok);
+    autosizeCondenserDesignAirFlowRate();
+    ok = setCondenserAirFlowSizingFactor(1.0);  // IDD default
+    OS_ASSERT(ok);
+    ok = setCondenserType("AirCooled");  // IDD default
+    OS_ASSERT(ok);
+    ok = setEvaporativeCondenserEffectiveness(0.7);  // IDD default
+    OS_ASSERT(ok);
+    ok = setEvaporativeCondenserPumpRatedPowerConsumption(0.0);  // IDD default
+    OS_ASSERT(ok);
+    ok = setBasinHeaterCapacity(0.0);  // IDD default
+    OS_ASSERT(ok);
+    ok = setBasinHeaterSetpointTemperature(2.0);  // IDD default
+    OS_ASSERT(ok);
+  }
+
+  IddObjectType CoilCoolingDXSingleSpeedThermalStorage::iddObjectType() {
+    return {IddObjectType::OS_Coil_Cooling_DX_SingleSpeed_ThermalStorage};
+  }
+
+  std::vector<std::string> CoilCoolingDXSingleSpeedThermalStorage::operatingModeControlMethodValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
+                          OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::OperatingModeControlMethod);
+  }
+
+  std::vector<std::string> CoilCoolingDXSingleSpeedThermalStorage::storageTypeValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::StorageType);
+  }
+
+  std::vector<std::string> CoilCoolingDXSingleSpeedThermalStorage::condenserTypeValues() {
+    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
+                          OS_Coil_Cooling_DX_SingleSpeed_ThermalStorageFields::CondenserType);
+  }
+
+  Schedule CoilCoolingDXSingleSpeedThermalStorage::availabilitySchedule() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->availabilitySchedule();
+  }
+
+  std::string CoilCoolingDXSingleSpeedThermalStorage::operatingModeControlMethod() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->operatingModeControlMethod();
+  }
+
+  boost::optional<Schedule> CoilCoolingDXSingleSpeedThermalStorage::operationModeControlSchedule() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->operationModeControlSchedule();
+  }
+
+  std::string CoilCoolingDXSingleSpeedThermalStorage::storageType() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->storageType();
+  }
+
+  int CoilCoolingDXSingleSpeedThermalStorage::glycolConcentration() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->glycolConcentration();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::fluidStorageVolume() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->fluidStorageVolume();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isFluidStorageVolumeAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isFluidStorageVolumeAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedFluidStorageVolume() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedFluidStorageVolume();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::iceStorageCapacity() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->iceStorageCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isIceStorageCapacityAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isIceStorageCapacityAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedIceStorageCapacity() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedIceStorageCapacity();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::storageCapacitySizingFactor() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->storageCapacitySizingFactor();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::fluidStorageTankRatingTemperature() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->fluidStorageTankRatingTemperature();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::ratedEvaporatorAirFlowRate() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->ratedEvaporatorAirFlowRate();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isRatedEvaporatorAirFlowRateAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isRatedEvaporatorAirFlowRateAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedRatedEvaporatorAirFlowRate() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedRatedEvaporatorAirFlowRate();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeAvailable() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeAvailable();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeRatedTotalEvaporatorCoolingCapacity() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isCoolingOnlyModeRatedTotalEvaporatorCoolingCapacityAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isCoolingOnlyModeRatedTotalEvaporatorCoolingCapacityAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeRatedSensibleHeatRatio() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeRatedSensibleHeatRatio();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeRatedCOP() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeRatedCOP();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModePartLoadFractionCorrelationCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModePartLoadFractionCorrelationCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeAvailable() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeAvailable();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacityAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacityAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeCapacitySizingFactor() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeCapacitySizingFactor();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeRatedStorageChargingCapacity() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeRatedStorageChargingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isCoolingAndChargeModeRatedStorageChargingCapacityAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isCoolingAndChargeModeRatedStorageChargingCapacityAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedCoolingAndChargeModeRatedStorageChargingCapacity() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedCoolingAndChargeModeRatedStorageChargingCapacity();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeStorageCapacitySizingFactor() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeStorageCapacitySizingFactor();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeRatedSensibleHeatRatio() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeRatedSensibleHeatRatio();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeCoolingRatedCOP() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeCoolingRatedCOP();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeChargingRatedCOP() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeChargingRatedCOP();
+  }
+
+  boost::optional<Curve>
+    CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve>
+    CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeAvailable() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeAvailable();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacityAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacityAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeEvaporatorCapacitySizingFactor() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeEvaporatorCapacitySizingFactor();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeRatedStorageDischargingCapacity() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeRatedStorageDischargingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isCoolingAndDischargeModeRatedStorageDischargingCapacityAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isCoolingAndDischargeModeRatedStorageDischargingCapacityAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedCoolingAndDischargeModeRatedStorageDischargingCapacity() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedCoolingAndDischargeModeRatedStorageDischargingCapacity();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeStorageDischargeCapacitySizingFactor() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeStorageDischargeCapacitySizingFactor();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeRatedSensibleHeatRatio() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeRatedSensibleHeatRatio();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeCoolingRatedCOP() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeCoolingRatedCOP();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeDischargingRatedCOP() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeDischargingRatedCOP();
+  }
+
+  boost::optional<Curve>
+    CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve>
+    CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve>
+    CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve>
+    CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::chargeOnlyModeAvailable() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->chargeOnlyModeAvailable();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::chargeOnlyModeRatedStorageChargingCapacity() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->chargeOnlyModeRatedStorageChargingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isChargeOnlyModeRatedStorageChargingCapacityAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isChargeOnlyModeRatedStorageChargingCapacityAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedChargeOnlyModeRatedStorageChargingCapacity() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedChargeOnlyModeRatedStorageChargingCapacity();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::chargeOnlyModeCapacitySizingFactor() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->chargeOnlyModeCapacitySizingFactor();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::chargeOnlyModeChargingRatedCOP() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->chargeOnlyModeChargingRatedCOP();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeAvailable() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeAvailable();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeRatedStorageDischargingCapacity() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeRatedStorageDischargingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isDischargeOnlyModeRatedStorageDischargingCapacityAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isDischargeOnlyModeRatedStorageDischargingCapacityAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedDischargeOnlyModeRatedStorageDischargingCapacity() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedDischargeOnlyModeRatedStorageDischargingCapacity();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeCapacitySizingFactor() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeCapacitySizingFactor();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeRatedSensibleHeatRatio() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeRatedSensibleHeatRatio();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeRatedCOP() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeRatedCOP();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModePartLoadFractionCorrelationCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModePartLoadFractionCorrelationCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+  }
+
+  boost::optional<Curve> CoilCoolingDXSingleSpeedThermalStorage::dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::ancillaryElectricPower() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->ancillaryElectricPower();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::coldWeatherOperationMinimumOutdoorAirTemperature() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coldWeatherOperationMinimumOutdoorAirTemperature();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::coldWeatherOperationAncillaryPower() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->coldWeatherOperationAncillaryPower();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::condenserDesignAirFlowRate() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->condenserDesignAirFlowRate();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isCondenserDesignAirFlowRateAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isCondenserDesignAirFlowRateAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedCondenserDesignAirFlowRate() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedCondenserDesignAirFlowRate();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::condenserAirFlowSizingFactor() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->condenserAirFlowSizingFactor();
+  }
+
+  std::string CoilCoolingDXSingleSpeedThermalStorage::condenserType() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->condenserType();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::evaporativeCondenserEffectiveness() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->evaporativeCondenserEffectiveness();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::evaporativeCondenserPumpRatedPowerConsumption() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->evaporativeCondenserPumpRatedPowerConsumption();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->isEvaporativeCondenserPumpRatedPowerConsumptionAutosized();
+  }
+
+  boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::autosizedEvaporativeCondenserPumpRatedPowerConsumption() {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizedEvaporativeCondenserPumpRatedPowerConsumption();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::basinHeaterCapacity() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->basinHeaterCapacity();
+  }
+
+  double CoilCoolingDXSingleSpeedThermalStorage::basinHeaterSetpointTemperature() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->basinHeaterSetpointTemperature();
+  }
+
+  boost::optional<Schedule> CoilCoolingDXSingleSpeedThermalStorage::basinHeaterAvailabilitySchedule() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->basinHeaterAvailabilitySchedule();
+  }
+
+  // boost::optional<WaterStorageTank> CoilCoolingDXSingleSpeedThermalStorage::supplyWaterStorageTank() const {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->supplyWaterStorageTank();
+  // }
+
+  // boost::optional<WaterStorageTank> CoilCoolingDXSingleSpeedThermalStorage::condensateCollectionWaterStorageTank() const {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->condensateCollectionWaterStorageTank();
+  // }
+
+  // boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::storageTankPlantConnectionDesignFlowRate() const {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->storageTankPlantConnectionDesignFlowRate();
+  // }
+
+  // double CoilCoolingDXSingleSpeedThermalStorage::storageTankPlantConnectionHeatTransferEffectiveness() const {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->storageTankPlantConnectionHeatTransferEffectiveness();
+  // }
+
+  // boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::storageTankMinimumOperatingLimitFluidTemperature() const {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->storageTankMinimumOperatingLimitFluidTemperature();
+  // }
+
+  // boost::optional<double> CoilCoolingDXSingleSpeedThermalStorage::storageTankMaximumOperatingLimitFluidTemperature() const {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->storageTankMaximumOperatingLimitFluidTemperature();
+  // }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setAvailabilitySchedule(Schedule& schedule) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setAvailabilitySchedule(schedule);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setOperatingModeControlMethod(const std::string& operatingModeControlMethod) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setOperatingModeControlMethod(operatingModeControlMethod);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setOperationModeControlSchedule(Schedule& schedule) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setOperationModeControlSchedule(schedule);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetOperationModeControlSchedule() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetOperationModeControlSchedule();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setStorageType(const std::string& storageType) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setStorageType(storageType);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setGlycolConcentration(int glycolConcentration) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setGlycolConcentration(glycolConcentration);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setFluidStorageVolume(double fluidStorageVolume) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setFluidStorageVolume(fluidStorageVolume);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetFluidStorageVolume() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetFluidStorageVolume();
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeFluidStorageVolume() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeFluidStorageVolume();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setIceStorageCapacity(double iceStorageCapacity) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setIceStorageCapacity(iceStorageCapacity);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeIceStorageCapacity() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeIceStorageCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setStorageCapacitySizingFactor(double storageCapacitySizingFactor) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setStorageCapacitySizingFactor(storageCapacitySizingFactor);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setStorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient(
+    double storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setStorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient(
+      storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setFluidStorageTankRatingTemperature(double fluidStorageTankRatingTemperature) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setFluidStorageTankRatingTemperature(fluidStorageTankRatingTemperature);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setRatedEvaporatorAirFlowRate(double ratedEvaporatorAirFlowRate) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setRatedEvaporatorAirFlowRate(ratedEvaporatorAirFlowRate);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeRatedEvaporatorAirFlowRate() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeRatedEvaporatorAirFlowRate();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeAvailable(bool coolingOnlyModeAvailable) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModeAvailable(coolingOnlyModeAvailable);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity(
+    double coolingOnlyModeRatedTotalEvaporatorCoolingCapacity) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity(
+      coolingOnlyModeRatedTotalEvaporatorCoolingCapacity);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeRatedSensibleHeatRatio(double coolingOnlyModeRatedSensibleHeatRatio) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModeRatedSensibleHeatRatio(
+      coolingOnlyModeRatedSensibleHeatRatio);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeRatedCOP(double coolingOnlyModeRatedCOP) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModeRatedCOP(coolingOnlyModeRatedCOP);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModePartLoadFractionCorrelationCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModePartLoadFractionCorrelationCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingOnlyModePartLoadFractionCorrelationCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingOnlyModePartLoadFractionCorrelationCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeAvailable(bool coolingAndChargeModeAvailable) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeAvailable(coolingAndChargeModeAvailable);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity(
+    double coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity(
+      coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeCapacitySizingFactor(double coolingAndChargeModeCapacitySizingFactor) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeCapacitySizingFactor(
+      coolingAndChargeModeCapacitySizingFactor);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeRatedStorageChargingCapacity(
+    double coolingAndChargeModeRatedStorageChargingCapacity) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeRatedStorageChargingCapacity(
+      coolingAndChargeModeRatedStorageChargingCapacity);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeCoolingAndChargeModeRatedStorageChargingCapacity() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeCoolingAndChargeModeRatedStorageChargingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeStorageCapacitySizingFactor(
+    double coolingAndChargeModeStorageCapacitySizingFactor) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeStorageCapacitySizingFactor(
+      coolingAndChargeModeStorageCapacitySizingFactor);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeRatedSensibleHeatRatio(double coolingAndChargeModeRatedSensibleHeatRatio) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeRatedSensibleHeatRatio(
+      coolingAndChargeModeRatedSensibleHeatRatio);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeCoolingRatedCOP(double coolingAndChargeModeCoolingRatedCOP) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeCoolingRatedCOP(
+      coolingAndChargeModeCoolingRatedCOP);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeChargingRatedCOP(double coolingAndChargeModeChargingRatedCOP) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeChargingRatedCOP(
+      coolingAndChargeModeChargingRatedCOP);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeAvailable(bool coolingAndDischargeModeAvailable) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeAvailable(coolingAndDischargeModeAvailable);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity(
+    double coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity(
+      coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeEvaporatorCapacitySizingFactor(
+    double coolingAndDischargeModeEvaporatorCapacitySizingFactor) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeEvaporatorCapacitySizingFactor(
+      coolingAndDischargeModeEvaporatorCapacitySizingFactor);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeRatedStorageDischargingCapacity(
+    double coolingAndDischargeModeRatedStorageDischargingCapacity) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeRatedStorageDischargingCapacity(
+      coolingAndDischargeModeRatedStorageDischargingCapacity);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeCoolingAndDischargeModeRatedStorageDischargingCapacity() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeCoolingAndDischargeModeRatedStorageDischargingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeStorageDischargeCapacitySizingFactor(
+    double coolingAndDischargeModeStorageDischargeCapacitySizingFactor) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeStorageDischargeCapacitySizingFactor(
+      coolingAndDischargeModeStorageDischargeCapacitySizingFactor);
+  }
+
+  bool
+    CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeRatedSensibleHeatRatio(double coolingAndDischargeModeRatedSensibleHeatRatio) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeRatedSensibleHeatRatio(
+      coolingAndDischargeModeRatedSensibleHeatRatio);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeCoolingRatedCOP(double coolingAndDischargeModeCoolingRatedCOP) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeCoolingRatedCOP(
+      coolingAndDischargeModeCoolingRatedCOP);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeDischargingRatedCOP(double coolingAndDischargeModeDischargingRatedCOP) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeDischargingRatedCOP(
+      coolingAndDischargeModeDischargingRatedCOP);
+  }
+
+  bool
+    CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+  }
+
+  bool
+    CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+  }
+
+  bool
+    CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()
+      ->setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setChargeOnlyModeAvailable(bool chargeOnlyModeAvailable) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setChargeOnlyModeAvailable(chargeOnlyModeAvailable);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setChargeOnlyModeRatedStorageChargingCapacity(double chargeOnlyModeRatedStorageChargingCapacity) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setChargeOnlyModeRatedStorageChargingCapacity(
+      chargeOnlyModeRatedStorageChargingCapacity);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeChargeOnlyModeRatedStorageChargingCapacity() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeChargeOnlyModeRatedStorageChargingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setChargeOnlyModeCapacitySizingFactor(double chargeOnlyModeCapacitySizingFactor) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setChargeOnlyModeCapacitySizingFactor(chargeOnlyModeCapacitySizingFactor);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setChargeOnlyModeChargingRatedCOP(double chargeOnlyModeChargingRatedCOP) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setChargeOnlyModeChargingRatedCOP(chargeOnlyModeChargingRatedCOP);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeAvailable(bool dischargeOnlyModeAvailable) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeAvailable(dischargeOnlyModeAvailable);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeRatedStorageDischargingCapacity(
+    double dischargeOnlyModeRatedStorageDischargingCapacity) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeRatedStorageDischargingCapacity(
+      dischargeOnlyModeRatedStorageDischargingCapacity);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeDischargeOnlyModeRatedStorageDischargingCapacity() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeDischargeOnlyModeRatedStorageDischargingCapacity();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeCapacitySizingFactor(double dischargeOnlyModeCapacitySizingFactor) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeCapacitySizingFactor(
+      dischargeOnlyModeCapacitySizingFactor);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeRatedSensibleHeatRatio(double dischargeOnlyModeRatedSensibleHeatRatio) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeRatedSensibleHeatRatio(
+      dischargeOnlyModeRatedSensibleHeatRatio);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeRatedCOP(double dischargeOnlyModeRatedCOP) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeRatedCOP(dischargeOnlyModeRatedCOP);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve(
+      Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModePartLoadFractionCorrelationCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModePartLoadFractionCorrelationCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetDischargeOnlyModePartLoadFractionCorrelationCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetDischargeOnlyModePartLoadFractionCorrelationCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(Curve);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setAncillaryElectricPower(double ancillaryElectricPower) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setAncillaryElectricPower(ancillaryElectricPower);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setColdWeatherOperationMinimumOutdoorAirTemperature(
+    double coldWeatherOperationMinimumOutdoorAirTemperature) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setColdWeatherOperationMinimumOutdoorAirTemperature(
+      coldWeatherOperationMinimumOutdoorAirTemperature);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetColdWeatherOperationMinimumOutdoorAirTemperature() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetColdWeatherOperationMinimumOutdoorAirTemperature();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setColdWeatherOperationAncillaryPower(double coldWeatherOperationAncillaryPower) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setColdWeatherOperationAncillaryPower(coldWeatherOperationAncillaryPower);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCondenserDesignAirFlowRate(double condenserDesignAirFlowRate) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCondenserDesignAirFlowRate(condenserDesignAirFlowRate);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeCondenserDesignAirFlowRate() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeCondenserDesignAirFlowRate();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCondenserAirFlowSizingFactor(double condenserAirFlowSizingFactor) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCondenserAirFlowSizingFactor(condenserAirFlowSizingFactor);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setCondenserType(const std::string& condenserType) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCondenserType(condenserType);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setEvaporativeCondenserEffectiveness(double evaporativeCondenserEffectiveness) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setEvaporativeCondenserEffectiveness(evaporativeCondenserEffectiveness);
+  }
+
+  bool
+    CoilCoolingDXSingleSpeedThermalStorage::setEvaporativeCondenserPumpRatedPowerConsumption(double evaporativeCondenserPumpRatedPowerConsumption) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setEvaporativeCondenserPumpRatedPowerConsumption(
+      evaporativeCondenserPumpRatedPowerConsumption);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::autosizeEvaporativeCondenserPumpRatedPowerConsumption() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->autosizeEvaporativeCondenserPumpRatedPowerConsumption();
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setBasinHeaterCapacity(double basinHeaterCapacity) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setBasinHeaterCapacity(basinHeaterCapacity);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setBasinHeaterSetpointTemperature(double basinHeaterSetpointTemperature) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setBasinHeaterSetpointTemperature(basinHeaterSetpointTemperature);
+  }
+
+  bool CoilCoolingDXSingleSpeedThermalStorage::setBasinHeaterAvailabilitySchedule(Schedule& schedule) {
+    return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setBasinHeaterAvailabilitySchedule(schedule);
+  }
+
+  void CoilCoolingDXSingleSpeedThermalStorage::resetBasinHeaterAvailabilitySchedule() {
+    getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetBasinHeaterAvailabilitySchedule();
+  }
+
+  // bool CoilCoolingDXSingleSpeedThermalStorage::setSupplyWaterStorageTank(const WaterStorageTank& waterStorageTank) {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setSupplyWaterStorageTank(waterStorageTank);
+  // }
+
+  // void CoilCoolingDXSingleSpeedThermalStorage::resetSupplyWaterStorageTank() {
+  // getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetSupplyWaterStorageTank();
+  // }
+
+  // bool CoilCoolingDXSingleSpeedThermalStorage::setCondensateCollectionWaterStorageTank(const WaterStorageTank& waterStorageTank) {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setCondensateCollectionWaterStorageTank(waterStorageTank);
+  // }
+
+  // void CoilCoolingDXSingleSpeedThermalStorage::resetCondensateCollectionWaterStorageTank() {
+  // getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetCondensateCollectionWaterStorageTank();
+  // }
+
+  // bool CoilCoolingDXSingleSpeedThermalStorage::setStorageTankPlantConnectionDesignFlowRate(double storageTankPlantConnectionDesignFlowRate) {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setStorageTankPlantConnectionDesignFlowRate(
+  // storageTankPlantConnectionDesignFlowRate);
+  // }
+
+  // void CoilCoolingDXSingleSpeedThermalStorage::resetStorageTankPlantConnectionDesignFlowRate() {
+  // getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetStorageTankPlantConnectionDesignFlowRate();
+  // }
+
+  // bool CoilCoolingDXSingleSpeedThermalStorage::setStorageTankPlantConnectionHeatTransferEffectiveness(
+  // double storageTankPlantConnectionHeatTransferEffectiveness) {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setStorageTankPlantConnectionHeatTransferEffectiveness(
+  // storageTankPlantConnectionHeatTransferEffectiveness);
+  // }
+
+  // bool CoilCoolingDXSingleSpeedThermalStorage::setStorageTankMinimumOperatingLimitFluidTemperature(
+  // double storageTankMinimumOperatingLimitFluidTemperature) {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setStorageTankMinimumOperatingLimitFluidTemperature(
+  // storageTankMinimumOperatingLimitFluidTemperature);
+  // }
+
+  // void CoilCoolingDXSingleSpeedThermalStorage::resetStorageTankMinimumOperatingLimitFluidTemperature() {
+  // getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetStorageTankMinimumOperatingLimitFluidTemperature();
+  // }
+
+  // bool CoilCoolingDXSingleSpeedThermalStorage::setStorageTankMaximumOperatingLimitFluidTemperature(
+  // double storageTankMaximumOperatingLimitFluidTemperature) {
+  // return getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->setStorageTankMaximumOperatingLimitFluidTemperature(
+  // storageTankMaximumOperatingLimitFluidTemperature);
+  // }
+
+  // void CoilCoolingDXSingleSpeedThermalStorage::resetStorageTankMaximumOperatingLimitFluidTemperature() {
+  // getImpl<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl>()->resetStorageTankMaximumOperatingLimitFluidTemperature();
+  // }
+
+  /// @cond
+  CoilCoolingDXSingleSpeedThermalStorage::CoilCoolingDXSingleSpeedThermalStorage(
+    std::shared_ptr<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl> impl)
+    : StraightComponent(std::move(impl)) {}
+  /// @endcond
+
+}  // namespace model
+}  // namespace openstudio
diff --git a/src/model/CoilCoolingDXSingleSpeedThermalStorage.hpp b/src/model/CoilCoolingDXSingleSpeedThermalStorage.hpp
new file mode 100644
index 00000000000..e2fcb788246
--- /dev/null
+++ b/src/model/CoilCoolingDXSingleSpeedThermalStorage.hpp
@@ -0,0 +1,675 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2023, 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_COILCOOLINGDXSINGLESPEEDTHERMALSTORAGE_HPP
+#define MODEL_COILCOOLINGDXSINGLESPEEDTHERMALSTORAGE_HPP
+
+#include <model/ModelAPI.hpp>
+#include "StraightComponent.hpp"
+
+namespace openstudio {
+
+namespace model {
+
+  class Schedule;
+  class Curve;
+
+  namespace detail {
+
+    class CoilCoolingDXSingleSpeedThermalStorage_Impl;
+
+  }  // namespace detail
+
+  /** CoilCoolingDXSingleSpeedThermalStorage is a StraightComponent that wraps the OpenStudio IDD object 'OS:Coil:Cooling:DX:SingleSpeed:ThermalStorage'. */
+  class MODEL_API CoilCoolingDXSingleSpeedThermalStorage : public StraightComponent
+  {
+   public:
+    /** @name Constructors and Destructors */
+    //@{
+
+    explicit CoilCoolingDXSingleSpeedThermalStorage(const Model& model);
+
+    virtual ~CoilCoolingDXSingleSpeedThermalStorage() = default;
+    // Default the copy and move operators because the virtual dtor is explicit
+    CoilCoolingDXSingleSpeedThermalStorage(const CoilCoolingDXSingleSpeedThermalStorage& other) = default;
+    CoilCoolingDXSingleSpeedThermalStorage(CoilCoolingDXSingleSpeedThermalStorage&& other) = default;
+    CoilCoolingDXSingleSpeedThermalStorage& operator=(const CoilCoolingDXSingleSpeedThermalStorage&) = default;
+    CoilCoolingDXSingleSpeedThermalStorage& operator=(CoilCoolingDXSingleSpeedThermalStorage&&) = default;
+
+    //@}
+
+    static IddObjectType iddObjectType();
+
+    static std::vector<std::string> operatingModeControlMethodValues();
+
+    static std::vector<std::string> storageTypeValues();
+
+    static std::vector<std::string> condenserTypeValues();
+
+    /** @name Getters */
+    //@{
+
+    Schedule availabilitySchedule() const;
+
+    std::string operatingModeControlMethod() const;
+
+    boost::optional<Schedule> operationModeControlSchedule() const;
+
+    std::string storageType() const;
+
+    int glycolConcentration() const;
+
+    boost::optional<double> fluidStorageVolume() const;
+
+    bool isFluidStorageVolumeAutosized() const;
+
+    boost::optional<double> iceStorageCapacity() const;
+
+    bool isIceStorageCapacityAutosized() const;
+
+    boost::optional<double> storageCapacitySizingFactor() const;
+
+    double storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient() const;
+
+    double fluidStorageTankRatingTemperature() const;
+
+    boost::optional<double> ratedEvaporatorAirFlowRate() const;
+
+    bool isRatedEvaporatorAirFlowRateAutosized() const;
+
+    bool coolingOnlyModeAvailable() const;
+
+    boost::optional<double> coolingOnlyModeRatedTotalEvaporatorCoolingCapacity() const;
+
+    bool isCoolingOnlyModeRatedTotalEvaporatorCoolingCapacityAutosized() const;
+
+    double coolingOnlyModeRatedSensibleHeatRatio() const;
+
+    double coolingOnlyModeRatedCOP() const;
+
+    boost::optional<Curve> coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> coolingOnlyModePartLoadFractionCorrelationCurve() const;
+
+    boost::optional<Curve> coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() const;
+
+    bool coolingAndChargeModeAvailable() const;
+
+    boost::optional<double> coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity() const;
+
+    bool isCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacityAutosized() const;
+
+    double coolingAndChargeModeCapacitySizingFactor() const;
+
+    boost::optional<double> coolingAndChargeModeRatedStorageChargingCapacity() const;
+
+    bool isCoolingAndChargeModeRatedStorageChargingCapacityAutosized() const;
+
+    double coolingAndChargeModeStorageCapacitySizingFactor() const;
+
+    double coolingAndChargeModeRatedSensibleHeatRatio() const;
+
+    double coolingAndChargeModeCoolingRatedCOP() const;
+
+    double coolingAndChargeModeChargingRatedCOP() const;
+
+    boost::optional<Curve> coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve() const;
+
+    bool coolingAndDischargeModeAvailable() const;
+
+    boost::optional<double> coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity() const;
+
+    bool isCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacityAutosized() const;
+
+    double coolingAndDischargeModeEvaporatorCapacitySizingFactor() const;
+
+    boost::optional<double> coolingAndDischargeModeRatedStorageDischargingCapacity() const;
+
+    bool isCoolingAndDischargeModeRatedStorageDischargingCapacityAutosized() const;
+
+    double coolingAndDischargeModeStorageDischargeCapacitySizingFactor() const;
+
+    double coolingAndDischargeModeRatedSensibleHeatRatio() const;
+
+    double coolingAndDischargeModeCoolingRatedCOP() const;
+
+    double coolingAndDischargeModeDischargingRatedCOP() const;
+
+    boost::optional<Curve> coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve() const;
+
+    bool chargeOnlyModeAvailable() const;
+
+    boost::optional<double> chargeOnlyModeRatedStorageChargingCapacity() const;
+
+    bool isChargeOnlyModeRatedStorageChargingCapacityAutosized() const;
+
+    double chargeOnlyModeCapacitySizingFactor() const;
+
+    double chargeOnlyModeChargingRatedCOP() const;
+
+    boost::optional<Curve> chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    bool dischargeOnlyModeAvailable() const;
+
+    boost::optional<double> dischargeOnlyModeRatedStorageDischargingCapacity() const;
+
+    bool isDischargeOnlyModeRatedStorageDischargingCapacityAutosized() const;
+
+    double dischargeOnlyModeCapacitySizingFactor() const;
+
+    double dischargeOnlyModeRatedSensibleHeatRatio() const;
+
+    double dischargeOnlyModeRatedCOP() const;
+
+    boost::optional<Curve> dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+    boost::optional<Curve> dischargeOnlyModePartLoadFractionCorrelationCurve() const;
+
+    boost::optional<Curve> dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() const;
+
+    boost::optional<Curve> dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() const;
+
+    boost::optional<double> ancillaryElectricPower() const;
+
+    boost::optional<double> coldWeatherOperationMinimumOutdoorAirTemperature() const;
+
+    boost::optional<double> coldWeatherOperationAncillaryPower() const;
+
+    boost::optional<double> condenserDesignAirFlowRate() const;
+
+    bool isCondenserDesignAirFlowRateAutosized() const;
+
+    double condenserAirFlowSizingFactor() const;
+
+    std::string condenserType() const;
+
+    double evaporativeCondenserEffectiveness() const;
+
+    boost::optional<double> evaporativeCondenserPumpRatedPowerConsumption() const;
+
+    bool isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() const;
+
+    double basinHeaterCapacity() const;
+
+    double basinHeaterSetpointTemperature() const;
+
+    boost::optional<Schedule> basinHeaterAvailabilitySchedule() const;
+
+    // boost::optional<WaterStorageTank> supplyWaterStorageTank() const;
+
+    // boost::optional<WaterStorageTank> condensateCollectionWaterStorageTank() const;
+
+    // boost::optional<double> storageTankPlantConnectionDesignFlowRate() const;
+
+    // double storageTankPlantConnectionHeatTransferEffectiveness() const;
+
+    // boost::optional<double> storageTankMinimumOperatingLimitFluidTemperature() const;
+
+    // boost::optional<double> storageTankMaximumOperatingLimitFluidTemperature() const;
+
+    //@}
+    /** @name Setters */
+    //@{
+
+    bool setAvailabilitySchedule(Schedule& schedule);
+
+    bool setOperatingModeControlMethod(const std::string& operatingModeControlMethod);
+
+    bool setOperationModeControlSchedule(Schedule& schedule);
+
+    void resetOperationModeControlSchedule();
+
+    bool setStorageType(const std::string& storageType);
+
+    bool setGlycolConcentration(int glycolConcentration);
+
+    bool setFluidStorageVolume(double fluidStorageVolume);
+
+    void resetFluidStorageVolume();
+
+    void autosizeFluidStorageVolume();
+
+    bool setIceStorageCapacity(double iceStorageCapacity);
+
+    void autosizeIceStorageCapacity();
+
+    bool setStorageCapacitySizingFactor(double storageCapacitySizingFactor);
+
+    bool setStorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient(double storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient);
+
+    bool setFluidStorageTankRatingTemperature(double fluidStorageTankRatingTemperature);
+
+    bool setRatedEvaporatorAirFlowRate(double ratedEvaporatorAirFlowRate);
+
+    void autosizeRatedEvaporatorAirFlowRate();
+
+    bool setCoolingOnlyModeAvailable(bool coolingOnlyModeAvailable);
+
+    bool setCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity(double coolingOnlyModeRatedTotalEvaporatorCoolingCapacity);
+
+    void autosizeCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+
+    bool setCoolingOnlyModeRatedSensibleHeatRatio(double coolingOnlyModeRatedSensibleHeatRatio);
+
+    bool setCoolingOnlyModeRatedCOP(double coolingOnlyModeRatedCOP);
+
+    bool setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+
+    bool setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+
+    bool setCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+
+    bool setCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+
+    bool setCoolingOnlyModePartLoadFractionCorrelationCurve(const Curve& Curve);
+
+    void resetCoolingOnlyModePartLoadFractionCorrelationCurve();
+
+    bool setCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+
+    bool setCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+
+    bool setCoolingAndChargeModeAvailable(bool coolingAndChargeModeAvailable);
+
+    bool setCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity(double coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity);
+
+    void autosizeCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+
+    bool setCoolingAndChargeModeCapacitySizingFactor(double coolingAndChargeModeCapacitySizingFactor);
+
+    bool setCoolingAndChargeModeRatedStorageChargingCapacity(double coolingAndChargeModeRatedStorageChargingCapacity);
+
+    void autosizeCoolingAndChargeModeRatedStorageChargingCapacity();
+
+    bool setCoolingAndChargeModeStorageCapacitySizingFactor(double coolingAndChargeModeStorageCapacitySizingFactor);
+
+    bool setCoolingAndChargeModeRatedSensibleHeatRatio(double coolingAndChargeModeRatedSensibleHeatRatio);
+
+    bool setCoolingAndChargeModeCoolingRatedCOP(double coolingAndChargeModeCoolingRatedCOP);
+
+    bool setCoolingAndChargeModeChargingRatedCOP(double coolingAndChargeModeChargingRatedCOP);
+
+    bool setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+
+    bool setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+
+    bool setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+
+    bool setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+
+    bool setCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve();
+
+    bool setCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve();
+
+    bool setCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve();
+
+    bool setCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+
+    bool setCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+
+    bool setCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+
+    bool setCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+
+    bool setCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+
+    bool setCoolingAndDischargeModeAvailable(bool coolingAndDischargeModeAvailable);
+
+    bool setCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity(double coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity);
+
+    void autosizeCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+
+    bool setCoolingAndDischargeModeEvaporatorCapacitySizingFactor(double coolingAndDischargeModeEvaporatorCapacitySizingFactor);
+
+    bool setCoolingAndDischargeModeRatedStorageDischargingCapacity(double coolingAndDischargeModeRatedStorageDischargingCapacity);
+
+    void autosizeCoolingAndDischargeModeRatedStorageDischargingCapacity();
+
+    bool setCoolingAndDischargeModeStorageDischargeCapacitySizingFactor(double coolingAndDischargeModeStorageDischargeCapacitySizingFactor);
+
+    bool setCoolingAndDischargeModeRatedSensibleHeatRatio(double coolingAndDischargeModeRatedSensibleHeatRatio);
+
+    bool setCoolingAndDischargeModeCoolingRatedCOP(double coolingAndDischargeModeCoolingRatedCOP);
+
+    bool setCoolingAndDischargeModeDischargingRatedCOP(double coolingAndDischargeModeDischargingRatedCOP);
+
+    bool setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+
+    bool setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+
+    bool setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+
+    bool setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+
+    bool setCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve();
+
+    bool setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve();
+
+    bool setCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+
+    bool setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve();
+
+    bool setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+
+    bool setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+
+    bool setCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+
+    bool setCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+
+    bool setCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+
+    bool setChargeOnlyModeAvailable(bool chargeOnlyModeAvailable);
+
+    bool setChargeOnlyModeRatedStorageChargingCapacity(double chargeOnlyModeRatedStorageChargingCapacity);
+
+    void autosizeChargeOnlyModeRatedStorageChargingCapacity();
+
+    bool setChargeOnlyModeCapacitySizingFactor(double chargeOnlyModeCapacitySizingFactor);
+
+    bool setChargeOnlyModeChargingRatedCOP(double chargeOnlyModeChargingRatedCOP);
+
+    bool setChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve();
+
+    bool setChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+
+    bool setDischargeOnlyModeAvailable(bool dischargeOnlyModeAvailable);
+
+    bool setDischargeOnlyModeRatedStorageDischargingCapacity(double dischargeOnlyModeRatedStorageDischargingCapacity);
+
+    void autosizeDischargeOnlyModeRatedStorageDischargingCapacity();
+
+    bool setDischargeOnlyModeCapacitySizingFactor(double dischargeOnlyModeCapacitySizingFactor);
+
+    bool setDischargeOnlyModeRatedSensibleHeatRatio(double dischargeOnlyModeRatedSensibleHeatRatio);
+
+    bool setDischargeOnlyModeRatedCOP(double dischargeOnlyModeRatedCOP);
+
+    bool setDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve();
+
+    bool setDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+
+    bool setDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+
+    bool setDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+
+    bool setDischargeOnlyModePartLoadFractionCorrelationCurve(const Curve& Curve);
+
+    void resetDischargeOnlyModePartLoadFractionCorrelationCurve();
+
+    bool setDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+    void resetDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+
+    bool setDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+    void resetDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+
+    bool setAncillaryElectricPower(double ancillaryElectricPower);
+
+    bool setColdWeatherOperationMinimumOutdoorAirTemperature(double coldWeatherOperationMinimumOutdoorAirTemperature);
+
+    void resetColdWeatherOperationMinimumOutdoorAirTemperature();
+
+    bool setColdWeatherOperationAncillaryPower(double coldWeatherOperationAncillaryPower);
+
+    bool setCondenserDesignAirFlowRate(double condenserDesignAirFlowRate);
+
+    void autosizeCondenserDesignAirFlowRate();
+
+    bool setCondenserAirFlowSizingFactor(double condenserAirFlowSizingFactor);
+
+    bool setCondenserType(const std::string& condenserType);
+
+    bool setEvaporativeCondenserEffectiveness(double evaporativeCondenserEffectiveness);
+
+    bool setEvaporativeCondenserPumpRatedPowerConsumption(double evaporativeCondenserPumpRatedPowerConsumption);
+
+    void autosizeEvaporativeCondenserPumpRatedPowerConsumption();
+
+    bool setBasinHeaterCapacity(double basinHeaterCapacity);
+
+    bool setBasinHeaterSetpointTemperature(double basinHeaterSetpointTemperature);
+
+    bool setBasinHeaterAvailabilitySchedule(Schedule& schedule);
+
+    void resetBasinHeaterAvailabilitySchedule();
+
+    // bool setSupplyWaterStorageTank(const WaterStorageTank& waterStorageTank);
+
+    // void resetSupplyWaterStorageTank();
+
+    // bool setCondensateCollectionWaterStorageTank(const WaterStorageTank& waterStorageTank);
+
+    // void resetCondensateCollectionWaterStorageTank();
+
+    // bool setStorageTankPlantConnectionDesignFlowRate(double storageTankPlantConnectionDesignFlowRate);
+
+    // void resetStorageTankPlantConnectionDesignFlowRate();
+
+    // bool setStorageTankPlantConnectionHeatTransferEffectiveness(double storageTankPlantConnectionHeatTransferEffectiveness);
+
+    // bool setStorageTankMinimumOperatingLimitFluidTemperature(double storageTankMinimumOperatingLimitFluidTemperature);
+
+    // void resetStorageTankMinimumOperatingLimitFluidTemperature();
+
+    // bool setStorageTankMaximumOperatingLimitFluidTemperature(double storageTankMaximumOperatingLimitFluidTemperature);
+
+    // void resetStorageTankMaximumOperatingLimitFluidTemperature();
+
+    //@}
+    /** @name Other */
+    //@{
+
+    boost::optional<double> autosizedFluidStorageVolume();
+
+    boost::optional<double> autosizedIceStorageCapacity();
+
+    boost::optional<double> autosizedRatedEvaporatorAirFlowRate();
+
+    boost::optional<double> autosizedCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+
+    boost::optional<double> autosizedCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+
+    boost::optional<double> autosizedCoolingAndChargeModeRatedStorageChargingCapacity();
+
+    boost::optional<double> autosizedCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+
+    boost::optional<double> autosizedCoolingAndDischargeModeRatedStorageDischargingCapacity();
+
+    boost::optional<double> autosizedChargeOnlyModeRatedStorageChargingCapacity();
+
+    boost::optional<double> autosizedDischargeOnlyModeRatedStorageDischargingCapacity();
+
+    boost::optional<double> autosizedCondenserDesignAirFlowRate();
+
+    boost::optional<double> autosizedEvaporativeCondenserPumpRatedPowerConsumption();
+
+    //@}
+   protected:
+    /// @cond
+    using ImplType = detail::CoilCoolingDXSingleSpeedThermalStorage_Impl;
+
+    explicit CoilCoolingDXSingleSpeedThermalStorage(std::shared_ptr<detail::CoilCoolingDXSingleSpeedThermalStorage_Impl> impl);
+
+    friend class detail::CoilCoolingDXSingleSpeedThermalStorage_Impl;
+    friend class Model;
+    friend class IdfObject;
+    friend class openstudio::detail::IdfObject_Impl;
+    /// @endcond
+   private:
+    REGISTER_LOGGER("openstudio.model.CoilCoolingDXSingleSpeedThermalStorage");
+  };
+
+  /** \relates CoilCoolingDXSingleSpeedThermalStorage*/
+  using OptionalCoilCoolingDXSingleSpeedThermalStorage = boost::optional<CoilCoolingDXSingleSpeedThermalStorage>;
+
+  /** \relates CoilCoolingDXSingleSpeedThermalStorage*/
+  using CoilCoolingDXSingleSpeedThermalStorageVector = std::vector<CoilCoolingDXSingleSpeedThermalStorage>;
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_COILCOOLINGDXSINGLESPEEDTHERMALSTORAGE_HPP
diff --git a/src/model/CoilCoolingDXSingleSpeedThermalStorage_Impl.hpp b/src/model/CoilCoolingDXSingleSpeedThermalStorage_Impl.hpp
new file mode 100644
index 00000000000..ec00d5fb006
--- /dev/null
+++ b/src/model/CoilCoolingDXSingleSpeedThermalStorage_Impl.hpp
@@ -0,0 +1,677 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2023, 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_COILCOOLINGDXSINGLESPEEDTHERMALSTORAGE_IMPL_HPP
+#define MODEL_COILCOOLINGDXSINGLESPEEDTHERMALSTORAGE_IMPL_HPP
+
+#include <model/ModelAPI.hpp>
+#include "StraightComponent_Impl.hpp"
+
+namespace openstudio {
+namespace model {
+
+  class Schedule;
+  class Curve;
+
+  namespace detail {
+
+    /** CoilCoolingDXSingleSpeedThermalStorage_Impl is a StraightComponent_Impl that is the implementation class for CoilCoolingDXSingleSpeedThermalStorage.*/
+    class MODEL_API CoilCoolingDXSingleSpeedThermalStorage_Impl : public StraightComponent_Impl
+    {
+     public:
+      /** @name Constructors and Destructors */
+      //@{
+
+      CoilCoolingDXSingleSpeedThermalStorage_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle);
+
+      CoilCoolingDXSingleSpeedThermalStorage_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle);
+
+      CoilCoolingDXSingleSpeedThermalStorage_Impl(const CoilCoolingDXSingleSpeedThermalStorage_Impl& other, Model_Impl* model, bool keepHandle);
+
+      virtual ~CoilCoolingDXSingleSpeedThermalStorage_Impl() = default;
+
+      //@}
+      /** @name Virtual Methods */
+      //@{
+
+      virtual const std::vector<std::string>& outputVariableNames() const override;
+
+      virtual IddObjectType iddObjectType() const override;
+
+      virtual std::vector<ScheduleTypeKey> getScheduleTypeKeys(const Schedule& schedule) const override;
+
+      virtual unsigned inletPort() const override;
+
+      virtual unsigned outletPort() const override;
+
+      virtual boost::optional<HVACComponent> containingHVACComponent() const override;
+
+      virtual bool addToNode(Node& node) override;
+
+      virtual std::vector<ModelObject> children() const override;
+
+      virtual ComponentType componentType() const override;
+      virtual std::vector<FuelType> coolingFuelTypes() const override;
+      virtual std::vector<FuelType> heatingFuelTypes() const override;
+      virtual std::vector<AppGFuelType> appGHeatingFuelTypes() const override;
+
+      //@}
+      /** @name Getters */
+      //@{
+
+      Schedule availabilitySchedule() const;
+
+      std::string operatingModeControlMethod() const;
+
+      boost::optional<Schedule> operationModeControlSchedule() const;
+
+      std::string storageType() const;
+
+      int glycolConcentration() const;
+
+      boost::optional<double> fluidStorageVolume() const;
+
+      bool isFluidStorageVolumeAutosized() const;
+
+      boost::optional<double> iceStorageCapacity() const;
+
+      bool isIceStorageCapacityAutosized() const;
+
+      boost::optional<double> storageCapacitySizingFactor() const;
+
+      double storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient() const;
+
+      double fluidStorageTankRatingTemperature() const;
+
+      boost::optional<double> ratedEvaporatorAirFlowRate() const;
+
+      bool isRatedEvaporatorAirFlowRateAutosized() const;
+
+      bool coolingOnlyModeAvailable() const;
+
+      boost::optional<double> coolingOnlyModeRatedTotalEvaporatorCoolingCapacity() const;
+
+      bool isCoolingOnlyModeRatedTotalEvaporatorCoolingCapacityAutosized() const;
+
+      double coolingOnlyModeRatedSensibleHeatRatio() const;
+
+      double coolingOnlyModeRatedCOP() const;
+
+      boost::optional<Curve> coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> coolingOnlyModePartLoadFractionCorrelationCurve() const;
+
+      boost::optional<Curve> coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() const;
+
+      bool coolingAndChargeModeAvailable() const;
+
+      boost::optional<double> coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity() const;
+
+      bool isCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacityAutosized() const;
+
+      double coolingAndChargeModeCapacitySizingFactor() const;
+
+      boost::optional<double> coolingAndChargeModeRatedStorageChargingCapacity() const;
+
+      bool isCoolingAndChargeModeRatedStorageChargingCapacityAutosized() const;
+
+      double coolingAndChargeModeStorageCapacitySizingFactor() const;
+
+      double coolingAndChargeModeRatedSensibleHeatRatio() const;
+
+      double coolingAndChargeModeCoolingRatedCOP() const;
+
+      double coolingAndChargeModeChargingRatedCOP() const;
+
+      boost::optional<Curve> coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve() const;
+
+      bool coolingAndDischargeModeAvailable() const;
+
+      boost::optional<double> coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity() const;
+
+      bool isCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacityAutosized() const;
+
+      double coolingAndDischargeModeEvaporatorCapacitySizingFactor() const;
+
+      boost::optional<double> coolingAndDischargeModeRatedStorageDischargingCapacity() const;
+
+      bool isCoolingAndDischargeModeRatedStorageDischargingCapacityAutosized() const;
+
+      double coolingAndDischargeModeStorageDischargeCapacitySizingFactor() const;
+
+      double coolingAndDischargeModeRatedSensibleHeatRatio() const;
+
+      double coolingAndDischargeModeCoolingRatedCOP() const;
+
+      double coolingAndDischargeModeDischargingRatedCOP() const;
+
+      boost::optional<Curve> coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve() const;
+
+      bool chargeOnlyModeAvailable() const;
+
+      boost::optional<double> chargeOnlyModeRatedStorageChargingCapacity() const;
+
+      bool isChargeOnlyModeRatedStorageChargingCapacityAutosized() const;
+
+      double chargeOnlyModeCapacitySizingFactor() const;
+
+      double chargeOnlyModeChargingRatedCOP() const;
+
+      boost::optional<Curve> chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      bool dischargeOnlyModeAvailable() const;
+
+      boost::optional<double> dischargeOnlyModeRatedStorageDischargingCapacity() const;
+
+      bool isDischargeOnlyModeRatedStorageDischargingCapacityAutosized() const;
+
+      double dischargeOnlyModeCapacitySizingFactor() const;
+
+      double dischargeOnlyModeRatedSensibleHeatRatio() const;
+
+      double dischargeOnlyModeRatedCOP() const;
+
+      boost::optional<Curve> dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve() const;
+
+      boost::optional<Curve> dischargeOnlyModePartLoadFractionCorrelationCurve() const;
+
+      boost::optional<Curve> dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve() const;
+
+      boost::optional<Curve> dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve() const;
+
+      boost::optional<double> ancillaryElectricPower() const;
+
+      boost::optional<double> coldWeatherOperationMinimumOutdoorAirTemperature() const;
+
+      boost::optional<double> coldWeatherOperationAncillaryPower() const;
+
+      boost::optional<double> condenserDesignAirFlowRate() const;
+
+      bool isCondenserDesignAirFlowRateAutosized() const;
+
+      double condenserAirFlowSizingFactor() const;
+
+      std::string condenserType() const;
+
+      double evaporativeCondenserEffectiveness() const;
+
+      boost::optional<double> evaporativeCondenserPumpRatedPowerConsumption() const;
+
+      bool isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() const;
+
+      double basinHeaterCapacity() const;
+
+      double basinHeaterSetpointTemperature() const;
+
+      boost::optional<Schedule> basinHeaterAvailabilitySchedule() const;
+
+      // boost::optional<WaterStorageTank> supplyWaterStorageTank() const;
+
+      // boost::optional<WaterStorageTank> condensateCollectionWaterStorageTank() const;
+
+      // boost::optional<double> storageTankPlantConnectionDesignFlowRate() const;
+
+      // double storageTankPlantConnectionHeatTransferEffectiveness() const;
+
+      // boost::optional<double> storageTankMinimumOperatingLimitFluidTemperature() const;
+
+      // boost::optional<double> storageTankMaximumOperatingLimitFluidTemperature() const;
+
+      //@}
+      /** @name Setters */
+      //@{
+
+      bool setAvailabilitySchedule(Schedule& schedule);
+
+      bool setOperatingModeControlMethod(const std::string& operatingModeControlMethod);
+
+      bool setOperationModeControlSchedule(Schedule& schedule);
+
+      void resetOperationModeControlSchedule();
+
+      bool setStorageType(const std::string& storageType);
+
+      bool setGlycolConcentration(int glycolConcentration);
+
+      bool setFluidStorageVolume(double fluidStorageVolume);
+
+      void resetFluidStorageVolume();
+
+      void autosizeFluidStorageVolume();
+
+      bool setIceStorageCapacity(double iceStorageCapacity);
+
+      void autosizeIceStorageCapacity();
+
+      bool setStorageCapacitySizingFactor(double storageCapacitySizingFactor);
+
+      bool setStorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient(double storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient);
+
+      bool setFluidStorageTankRatingTemperature(double fluidStorageTankRatingTemperature);
+
+      bool setRatedEvaporatorAirFlowRate(double ratedEvaporatorAirFlowRate);
+
+      void autosizeRatedEvaporatorAirFlowRate();
+
+      bool setCoolingOnlyModeAvailable(bool coolingOnlyModeAvailable);
+
+      bool setCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity(double coolingOnlyModeRatedTotalEvaporatorCoolingCapacity);
+
+      void autosizeCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+
+      bool setCoolingOnlyModeRatedSensibleHeatRatio(double coolingOnlyModeRatedSensibleHeatRatio);
+
+      bool setCoolingOnlyModeRatedCOP(double coolingOnlyModeRatedCOP);
+
+      bool setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+
+      bool setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+
+      bool setCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+
+      bool setCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+
+      bool setCoolingOnlyModePartLoadFractionCorrelationCurve(const Curve& Curve);
+
+      void resetCoolingOnlyModePartLoadFractionCorrelationCurve();
+
+      bool setCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+
+      bool setCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+
+      bool setCoolingAndChargeModeAvailable(bool coolingAndChargeModeAvailable);
+
+      bool setCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity(double coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity);
+
+      void autosizeCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+
+      bool setCoolingAndChargeModeCapacitySizingFactor(double coolingAndChargeModeCapacitySizingFactor);
+
+      bool setCoolingAndChargeModeRatedStorageChargingCapacity(double coolingAndChargeModeRatedStorageChargingCapacity);
+
+      void autosizeCoolingAndChargeModeRatedStorageChargingCapacity();
+
+      bool setCoolingAndChargeModeStorageCapacitySizingFactor(double coolingAndChargeModeStorageCapacitySizingFactor);
+
+      bool setCoolingAndChargeModeRatedSensibleHeatRatio(double coolingAndChargeModeRatedSensibleHeatRatio);
+
+      bool setCoolingAndChargeModeCoolingRatedCOP(double coolingAndChargeModeCoolingRatedCOP);
+
+      bool setCoolingAndChargeModeChargingRatedCOP(double coolingAndChargeModeChargingRatedCOP);
+
+      bool setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+
+      bool setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+
+      bool setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+
+      bool setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+
+      bool setCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve();
+
+      bool setCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve();
+
+      bool setCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve();
+
+      bool setCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+
+      bool setCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+
+      bool setCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+
+      bool setCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+
+      bool setCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+
+      bool setCoolingAndDischargeModeAvailable(bool coolingAndDischargeModeAvailable);
+
+      bool setCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity(double coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity);
+
+      void autosizeCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+
+      bool setCoolingAndDischargeModeEvaporatorCapacitySizingFactor(double coolingAndDischargeModeEvaporatorCapacitySizingFactor);
+
+      bool setCoolingAndDischargeModeRatedStorageDischargingCapacity(double coolingAndDischargeModeRatedStorageDischargingCapacity);
+
+      void autosizeCoolingAndDischargeModeRatedStorageDischargingCapacity();
+
+      bool setCoolingAndDischargeModeStorageDischargeCapacitySizingFactor(double coolingAndDischargeModeStorageDischargeCapacitySizingFactor);
+
+      bool setCoolingAndDischargeModeRatedSensibleHeatRatio(double coolingAndDischargeModeRatedSensibleHeatRatio);
+
+      bool setCoolingAndDischargeModeCoolingRatedCOP(double coolingAndDischargeModeCoolingRatedCOP);
+
+      bool setCoolingAndDischargeModeDischargingRatedCOP(double coolingAndDischargeModeDischargingRatedCOP);
+
+      bool setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve();
+
+      bool setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve();
+
+      bool setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve();
+
+      bool setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve();
+
+      bool setCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve();
+
+      bool setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve();
+
+      bool setCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+
+      bool setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve();
+
+      bool setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+
+      bool setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve();
+
+      bool setCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve();
+
+      bool setCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve();
+
+      bool setCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve();
+
+      bool setChargeOnlyModeAvailable(bool chargeOnlyModeAvailable);
+
+      bool setChargeOnlyModeRatedStorageChargingCapacity(double chargeOnlyModeRatedStorageChargingCapacity);
+
+      void autosizeChargeOnlyModeRatedStorageChargingCapacity();
+
+      bool setChargeOnlyModeCapacitySizingFactor(double chargeOnlyModeCapacitySizingFactor);
+
+      bool setChargeOnlyModeChargingRatedCOP(double chargeOnlyModeChargingRatedCOP);
+
+      bool setChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve();
+
+      bool setChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve();
+
+      bool setDischargeOnlyModeAvailable(bool dischargeOnlyModeAvailable);
+
+      bool setDischargeOnlyModeRatedStorageDischargingCapacity(double dischargeOnlyModeRatedStorageDischargingCapacity);
+
+      void autosizeDischargeOnlyModeRatedStorageDischargingCapacity();
+
+      bool setDischargeOnlyModeCapacitySizingFactor(double dischargeOnlyModeCapacitySizingFactor);
+
+      bool setDischargeOnlyModeRatedSensibleHeatRatio(double dischargeOnlyModeRatedSensibleHeatRatio);
+
+      bool setDischargeOnlyModeRatedCOP(double dischargeOnlyModeRatedCOP);
+
+      bool setDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve();
+
+      bool setDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve();
+
+      bool setDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve();
+
+      bool setDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve();
+
+      bool setDischargeOnlyModePartLoadFractionCorrelationCurve(const Curve& Curve);
+
+      void resetDischargeOnlyModePartLoadFractionCorrelationCurve();
+
+      bool setDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(const Curve& Curve);
+
+      void resetDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve();
+
+      bool setDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(const Curve& Curve);
+
+      void resetDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve();
+
+      bool setAncillaryElectricPower(double ancillaryElectricPower);
+
+      bool setColdWeatherOperationMinimumOutdoorAirTemperature(double coldWeatherOperationMinimumOutdoorAirTemperature);
+
+      void resetColdWeatherOperationMinimumOutdoorAirTemperature();
+
+      bool setColdWeatherOperationAncillaryPower(double coldWeatherOperationAncillaryPower);
+
+      bool setCondenserDesignAirFlowRate(double condenserDesignAirFlowRate);
+
+      void autosizeCondenserDesignAirFlowRate();
+
+      bool setCondenserAirFlowSizingFactor(double condenserAirFlowSizingFactor);
+
+      bool setCondenserType(const std::string& condenserType);
+
+      bool setEvaporativeCondenserEffectiveness(double evaporativeCondenserEffectiveness);
+
+      bool setEvaporativeCondenserPumpRatedPowerConsumption(double evaporativeCondenserPumpRatedPowerConsumption);
+
+      void autosizeEvaporativeCondenserPumpRatedPowerConsumption();
+
+      bool setBasinHeaterCapacity(double basinHeaterCapacity);
+
+      bool setBasinHeaterSetpointTemperature(double basinHeaterSetpointTemperature);
+
+      bool setBasinHeaterAvailabilitySchedule(Schedule& schedule);
+
+      void resetBasinHeaterAvailabilitySchedule();
+
+      // bool setSupplyWaterStorageTank(const WaterStorageTank& waterStorageTank);
+
+      // void resetSupplyWaterStorageTank();
+
+      // bool setCondensateCollectionWaterStorageTank(const WaterStorageTank& waterStorageTank);
+
+      // void resetCondensateCollectionWaterStorageTank();
+
+      // bool setStorageTankPlantConnectionDesignFlowRate(double storageTankPlantConnectionDesignFlowRate);
+
+      // void resetStorageTankPlantConnectionDesignFlowRate();
+
+      // bool setStorageTankPlantConnectionHeatTransferEffectiveness(double storageTankPlantConnectionHeatTransferEffectiveness);
+
+      // bool setStorageTankMinimumOperatingLimitFluidTemperature(double storageTankMinimumOperatingLimitFluidTemperature);
+
+      // void resetStorageTankMinimumOperatingLimitFluidTemperature();
+
+      // bool setStorageTankMaximumOperatingLimitFluidTemperature(double storageTankMaximumOperatingLimitFluidTemperature);
+
+      // void resetStorageTankMaximumOperatingLimitFluidTemperature();
+
+      virtual void autosize() override;
+
+      virtual void applySizingValues() override;
+
+      //@}
+      /** @name Other */
+      //@{
+
+      boost::optional<double> autosizedFluidStorageVolume();
+
+      boost::optional<double> autosizedIceStorageCapacity();
+
+      boost::optional<double> autosizedRatedEvaporatorAirFlowRate();
+
+      boost::optional<double> autosizedCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+
+      boost::optional<double> autosizedCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+
+      boost::optional<double> autosizedCoolingAndChargeModeRatedStorageChargingCapacity();
+
+      boost::optional<double> autosizedCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+
+      boost::optional<double> autosizedCoolingAndDischargeModeRatedStorageDischargingCapacity();
+
+      boost::optional<double> autosizedChargeOnlyModeRatedStorageChargingCapacity();
+
+      boost::optional<double> autosizedDischargeOnlyModeRatedStorageDischargingCapacity();
+
+      boost::optional<double> autosizedCondenserDesignAirFlowRate();
+
+      boost::optional<double> autosizedEvaporativeCondenserPumpRatedPowerConsumption();
+
+      //@}
+     protected:
+     private:
+      REGISTER_LOGGER("openstudio.model.CoilCoolingDXSingleSpeedThermalStorage");
+
+      boost::optional<Schedule> optionalAvailabilitySchedule() const;
+    };
+
+  }  // namespace detail
+
+}  // namespace model
+}  // namespace openstudio
+
+#endif  // MODEL_COILCOOLINGDXSINGLESPEEDTHERMALSTORAGE_IMPL_HPP
diff --git a/src/model/ConcreteModelObjects.hpp b/src/model/ConcreteModelObjects.hpp
index 40e218737ef..c71eaadc27c 100644
--- a/src/model/ConcreteModelObjects.hpp
+++ b/src/model/ConcreteModelObjects.hpp
@@ -96,6 +96,7 @@
 #include "CoilCoolingDXMultiSpeed.hpp"
 #include "CoilCoolingDXMultiSpeedStageData.hpp"
 #include "CoilCoolingDXSingleSpeed.hpp"
+#include "CoilCoolingDXSingleSpeedThermalStorage.hpp"
 #include "CoilCoolingDXTwoSpeed.hpp"
 #include "CoilCoolingDXTwoStageWithHumidityControlMode.hpp"
 #include "CoilCoolingDXVariableRefrigerantFlow.hpp"
@@ -648,6 +649,7 @@
 #include "CoilCoolingDXMultiSpeed_Impl.hpp"
 #include "CoilCoolingDXMultiSpeedStageData_Impl.hpp"
 #include "CoilCoolingDXSingleSpeed_Impl.hpp"
+#include "CoilCoolingDXSingleSpeedThermalStorage_Impl.hpp"
 #include "CoilCoolingDXTwoSpeed_Impl.hpp"
 #include "CoilCoolingDXTwoStageWithHumidityControlMode_Impl.hpp"
 #include "CoilCoolingDXVariableRefrigerantFlow_Impl.hpp"
diff --git a/src/model/Model.cpp b/src/model/Model.cpp
index e363f6483bc..a792e907030 100644
--- a/src/model/Model.cpp
+++ b/src/model/Model.cpp
@@ -3927,6 +3927,7 @@ namespace model {
     REGISTER_CONSTRUCTOR(CoilCoolingDXMultiSpeed);
     REGISTER_CONSTRUCTOR(CoilCoolingDXMultiSpeedStageData);
     REGISTER_CONSTRUCTOR(CoilCoolingDXSingleSpeed);
+    REGISTER_CONSTRUCTOR(CoilCoolingDXSingleSpeedThermalStorage);
     REGISTER_CONSTRUCTOR(CoilCoolingDXTwoSpeed);
     REGISTER_CONSTRUCTOR(CoilCoolingDXTwoStageWithHumidityControlMode);
     REGISTER_CONSTRUCTOR(CoilCoolingDXVariableRefrigerantFlow);
@@ -4499,6 +4500,7 @@ namespace model {
     REGISTER_COPYCONSTRUCTORS(CoilCoolingDXMultiSpeed);
     REGISTER_COPYCONSTRUCTORS(CoilCoolingDXMultiSpeedStageData);
     REGISTER_COPYCONSTRUCTORS(CoilCoolingDXSingleSpeed);
+    REGISTER_COPYCONSTRUCTORS(CoilCoolingDXSingleSpeedThermalStorage);
     REGISTER_COPYCONSTRUCTORS(CoilCoolingDXTwoSpeed);
     REGISTER_COPYCONSTRUCTORS(CoilCoolingDXTwoStageWithHumidityControlMode);
     REGISTER_COPYCONSTRUCTORS(CoilCoolingDXVariableRefrigerantFlow);
diff --git a/src/model/ModelStraightComponent.i b/src/model/ModelStraightComponent.i
index 525f332901b..3c835cceadf 100644
--- a/src/model/ModelStraightComponent.i
+++ b/src/model/ModelStraightComponent.i
@@ -119,6 +119,7 @@ MODELOBJECT_TEMPLATES(CoilCoolingCooledBeam);
 MODELOBJECT_TEMPLATES(CoilCoolingDX);
 MODELOBJECT_TEMPLATES(CoilCoolingDXMultiSpeed);
 MODELOBJECT_TEMPLATES(CoilCoolingDXSingleSpeed);
+MODELOBJECT_TEMPLATES(CoilCoolingDXSingleSpeedThermalStorage);
 MODELOBJECT_TEMPLATES(CoilCoolingDXTwoSpeed);
 MODELOBJECT_TEMPLATES(CoilCoolingDXTwoStageWithHumidityControlMode);
 MODELOBJECT_TEMPLATES(CoilCoolingDXVariableSpeed);
@@ -206,6 +207,7 @@ SWIG_MODELOBJECT(CoilCoolingCooledBeam,1);
 SWIG_MODELOBJECT(CoilCoolingDX,1);
 SWIG_MODELOBJECT(CoilCoolingDXMultiSpeed,1);
 SWIG_MODELOBJECT(CoilCoolingDXSingleSpeed,1);
+SWIG_MODELOBJECT(CoilCoolingDXSingleSpeedThermalStorage,1);
 SWIG_MODELOBJECT(CoilCoolingDXTwoSpeed,1);
 SWIG_MODELOBJECT(CoilCoolingDXTwoStageWithHumidityControlMode,1);
 SWIG_MODELOBJECT(CoilCoolingDXVariableSpeed,1);
diff --git a/src/model/ScheduleTypeRegistry.cpp b/src/model/ScheduleTypeRegistry.cpp
index 9d04068153a..142d34b9e5f 100644
--- a/src/model/ScheduleTypeRegistry.cpp
+++ b/src/model/ScheduleTypeRegistry.cpp
@@ -163,6 +163,10 @@ namespace model {
        "evaporativeCondenserBasinHeaterOperatingSchedule", false, "Availability", 0.0, 1.0},
       {"CoilCoolingDXSingleSpeed", "Availability", "availabilitySchedule", false, "Availability", 0.0, 1.0},
       {"CoilCoolingDXSingleSpeed", "Basin Heater Operation", "basinHeaterOperatingSchedule", false, "Availability", 0.0, 1.0},
+      {"CoilCoolingDXSingleSpeedThermalStorage", "Availability Schedule", "availabilitySchedule", false, "Availability", 0.0, 1.0},
+      {"CoilCoolingDXSingleSpeedThermalStorage", "Operation Mode Control Schedule", "operationModeControlSchedule", false, "", 0.0, 5.0},
+      {"CoilCoolingDXSingleSpeedThermalStorage", "Basin Heater Availability Schedule", "basinHeaterAvailabilitySchedule", false, "Availability", 0.0,
+       1.0},
       {"CoilCoolingDXTwoSpeed", "Availability", "availabilitySchedule", false, "Availability", 0.0, 1.0},
       {"CoilCoolingDXTwoSpeed", "Basin Heater Operation", "basinHeaterOperatingSchedule", false, "Availability", 0.0, 1.0},
       {"CoilCoolingDXTwoStageWithHumidityControlMode", "Availability Schedule", "availabilitySchedule", false, "Availability", 0.0, 1.0},


Test patch:
diff --git a/src/model/test/CoilCoolingDXSingleSpeedThermalStorage_GTest.cpp b/src/model/test/CoilCoolingDXSingleSpeedThermalStorage_GTest.cpp
new file mode 100644
index 00000000000..b8dfea681db
--- /dev/null
+++ b/src/model/test/CoilCoolingDXSingleSpeedThermalStorage_GTest.cpp
@@ -0,0 +1,1027 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2023, 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 "../CoilCoolingDXSingleSpeedThermalStorage.hpp"
+#include "../CoilCoolingDXSingleSpeedThermalStorage_Impl.hpp"
+
+#include "../ScheduleConstant.hpp"
+#include "../Curve.hpp"
+#include "../Curve_Impl.hpp"
+#include "../CurveBiquadratic.hpp"
+#include "../CurveBiquadratic_Impl.hpp"
+#include "../CurveQuadratic.hpp"
+#include "../CurveQuadratic_Impl.hpp"
+#include "../CurveTriquadratic.hpp"
+#include "../CurveTriquadratic_Impl.hpp"
+#include "../AirLoopHVACUnitarySystem.hpp"
+#include "../AirLoopHVACUnitarySystem_Impl.hpp"
+#include "../AirLoopHVAC.hpp"
+#include "../PlantLoop.hpp"
+#include "../Node.hpp"
+#include "../Node_Impl.hpp"
+#include "../CoilSystemCoolingDXHeatExchangerAssisted.hpp"
+#include "../ZoneHVACPackagedTerminalAirConditioner.hpp"
+#include "../ZoneHVACPackagedTerminalHeatPump.hpp"
+#include "../ScheduleCompact.hpp"
+#include "../CoilHeatingDXSingleSpeed.hpp"
+#include "../FanConstantVolume.hpp"
+#include "../CoilHeatingElectric.hpp"
+#include "../CoilHeatingWater.hpp"
+#include "../AirLoopHVACZoneSplitter.hpp"
+
+using namespace openstudio;
+using namespace openstudio::model;
+
+TEST_F(ModelFixture, CoilCoolingDXSingleSpeedThermalStorage_DefaultConstructors) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+
+  ASSERT_EXIT(
+    {
+      Model m;
+      CoilCoolingDXSingleSpeedThermalStorage testObject = CoilCoolingDXSingleSpeedThermalStorage(m);
+
+      exit(0);
+    },
+    ::testing::ExitedWithCode(0), "");
+}
+
+TEST_F(ModelFixture, CoilCoolingDXSingleSpeedThermalStorage_GettersSetters) {
+  Model m;
+
+  CoilCoolingDXSingleSpeedThermalStorage coilCoolingDXSingleSpeedThermalStorage(m);
+
+  coilCoolingDXSingleSpeedThermalStorage.setName("My CoilCoolingDXSingleSpeedThermalStorage");
+
+  // Availability Schedule: Required Object
+  ScheduleConstant availabilitySchedule(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setAvailabilitySchedule(availabilitySchedule));
+  EXPECT_EQ(availabilitySchedule, coilCoolingDXSingleSpeedThermalStorage.availabilitySchedule());
+
+  // Operating Mode Control Method: Required String
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setOperatingModeControlMethod("ScheduledModes"));
+  EXPECT_EQ("ScheduledModes", coilCoolingDXSingleSpeedThermalStorage.operatingModeControlMethod());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setOperatingModeControlMethod("BADENUM"));
+  EXPECT_EQ("ScheduledModes", coilCoolingDXSingleSpeedThermalStorage.operatingModeControlMethod());
+
+  // Operation Mode Control Schedule: Optional Object
+  ScheduleConstant operationModeControlSchedule(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setOperationModeControlSchedule(operationModeControlSchedule));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.operationModeControlSchedule());
+  EXPECT_EQ(operationModeControlSchedule, coilCoolingDXSingleSpeedThermalStorage.operationModeControlSchedule().get());
+
+  // Storage Type: Required String
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageType("Water"));
+  EXPECT_EQ("Water", coilCoolingDXSingleSpeedThermalStorage.storageType());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setStorageType("BADENUM"));
+  EXPECT_EQ("Water", coilCoolingDXSingleSpeedThermalStorage.storageType());
+
+  // Glycol Concentration: Required Integer
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setGlycolConcentration(50));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.glycolConcentration());
+  EXPECT_EQ(50, coilCoolingDXSingleSpeedThermalStorage.glycolConcentration());
+
+  // Fluid Storage Volume: Optional Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeFluidStorageVolume();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isFluidStorageVolumeAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setFluidStorageVolume(0.8));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.fluidStorageVolume());
+  EXPECT_EQ(0.8, coilCoolingDXSingleSpeedThermalStorage.fluidStorageVolume().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setFluidStorageVolume(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.fluidStorageVolume());
+  EXPECT_EQ(0.8, coilCoolingDXSingleSpeedThermalStorage.fluidStorageVolume().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isFluidStorageVolumeAutosized());
+
+  // Ice Storage Capacity: Optional Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeIceStorageCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isIceStorageCapacityAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setIceStorageCapacity(0.9));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.iceStorageCapacity());
+  EXPECT_EQ(0.9, coilCoolingDXSingleSpeedThermalStorage.iceStorageCapacity().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setIceStorageCapacity(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.iceStorageCapacity());
+  EXPECT_EQ(0.9, coilCoolingDXSingleSpeedThermalStorage.iceStorageCapacity().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isIceStorageCapacityAutosized());
+
+  // Storage Capacity Sizing Factor: Optional Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageCapacitySizingFactor(1.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.storageCapacitySizingFactor());
+  EXPECT_EQ(1.0, coilCoolingDXSingleSpeedThermalStorage.storageCapacitySizingFactor().get());
+
+  // Storage Tank to Ambient U-value Times Area Heat Transfer Coefficient: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient(1.2));
+  EXPECT_EQ(1.2, coilCoolingDXSingleSpeedThermalStorage.storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setStorageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient(-10.0));
+  EXPECT_EQ(1.2, coilCoolingDXSingleSpeedThermalStorage.storageTanktoAmbientUvalueTimesAreaHeatTransferCoefficient());
+
+  // Fluid Storage Tank Rating Temperature: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setFluidStorageTankRatingTemperature(1.3));
+  EXPECT_EQ(1.3, coilCoolingDXSingleSpeedThermalStorage.fluidStorageTankRatingTemperature());
+
+  // Rated Evaporator Air Flow Rate: Required Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeRatedEvaporatorAirFlowRate();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isRatedEvaporatorAirFlowRateAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setRatedEvaporatorAirFlowRate(1.4));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.ratedEvaporatorAirFlowRate());
+  EXPECT_EQ(1.4, coilCoolingDXSingleSpeedThermalStorage.ratedEvaporatorAirFlowRate().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setRatedEvaporatorAirFlowRate(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.ratedEvaporatorAirFlowRate());
+  EXPECT_EQ(1.4, coilCoolingDXSingleSpeedThermalStorage.ratedEvaporatorAirFlowRate().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isRatedEvaporatorAirFlowRateAutosized());
+
+  // Cooling Only Mode Available: Required Boolean
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeAvailable(true));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeAvailable());
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeAvailable(false));
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeAvailable());
+
+  // Cooling Only Mode Rated Total Evaporator Cooling Capacity: Optional Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isCoolingOnlyModeRatedTotalEvaporatorCoolingCapacityAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity(1.8));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeRatedTotalEvaporatorCoolingCapacity());
+  EXPECT_EQ(1.8, coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeRatedTotalEvaporatorCoolingCapacity().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeRatedTotalEvaporatorCoolingCapacity(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeRatedTotalEvaporatorCoolingCapacity());
+  EXPECT_EQ(1.8, coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeRatedTotalEvaporatorCoolingCapacity().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isCoolingOnlyModeRatedTotalEvaporatorCoolingCapacityAutosized());
+
+  // Cooling Only Mode Rated Sensible Heat Ratio: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeRatedSensibleHeatRatio(0.95));
+  EXPECT_EQ(0.95, coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeRatedSensibleHeatRatio());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeRatedSensibleHeatRatio(-10.0));
+  EXPECT_EQ(0.95, coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeRatedSensibleHeatRatio());
+
+  // Cooling Only Mode Rated COP: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeRatedCOP(2.0));
+  EXPECT_EQ(2.0, coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeRatedCOP());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeRatedCOP(-10.0));
+  EXPECT_EQ(2.0, coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeRatedCOP());
+
+  // Cooling Only Mode Total Evaporator Cooling Capacity Function of Temperature Curve: Optional Object
+  CurveBiquadratic coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(
+    coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve().get());
+
+  // Cooling Only Mode Total Evaporator Cooling Capacity Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(
+    coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve().get());
+
+  // Cooling Only Mode Energy Input Ratio Function of Temperature Curve: Optional Object
+  CurveBiquadratic coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve(
+    coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeEnergyInputRatioFunctionofTemperatureCurve().get());
+
+  // Cooling Only Mode Energy Input Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeEnergyInputRatioFunctionofFlowFractionCurve().get());
+
+  // Cooling Only Mode Part Load Fraction Correlation Curve: Optional Object
+  CurveQuadratic coolingOnlyModePartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(
+    coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModePartLoadFractionCorrelationCurve(coolingOnlyModePartLoadFractionCorrelationCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModePartLoadFractionCorrelationCurve());
+  EXPECT_EQ(coolingOnlyModePartLoadFractionCorrelationCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModePartLoadFractionCorrelationCurve().get());
+
+  // Cooling Only Mode Sensible Heat Ratio Function of Temperature Curve: Optional Object
+  CurveBiquadratic coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(
+    coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeSensibleHeatRatioFunctionofTemperatureCurve().get());
+
+  // Cooling Only Mode Sensible Heat Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(
+    coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve().get());
+
+  // Cooling And Charge Mode Available: Required Boolean
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeAvailable(true));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeAvailable());
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeAvailable(false));
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeAvailable());
+
+  // Cooling And Charge Mode Rated Total Evaporator Cooling Capacity: Optional Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacityAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity(2.9));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity());
+  EXPECT_EQ(2.9, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacity(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity());
+  EXPECT_EQ(2.9, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedTotalEvaporatorCoolingCapacity().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isCoolingAndChargeModeRatedTotalEvaporatorCoolingCapacityAutosized());
+
+  // Cooling And Charge Mode Capacity Sizing Factor: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeCapacitySizingFactor(3.0));
+  EXPECT_EQ(3.0, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeCapacitySizingFactor());
+
+  // Cooling And Charge Mode Rated Storage Charging Capacity: Optional Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingAndChargeModeRatedStorageChargingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isCoolingAndChargeModeRatedStorageChargingCapacityAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeRatedStorageChargingCapacity(3.1));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedStorageChargingCapacity());
+  EXPECT_EQ(3.1, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedStorageChargingCapacity().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeRatedStorageChargingCapacity(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedStorageChargingCapacity());
+  EXPECT_EQ(3.1, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedStorageChargingCapacity().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isCoolingAndChargeModeRatedStorageChargingCapacityAutosized());
+
+  // Cooling And Charge Mode Storage Capacity Sizing Factor: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageCapacitySizingFactor(3.2));
+  EXPECT_EQ(3.2, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageCapacitySizingFactor());
+
+  // Cooling And Charge Mode Rated Sensible Heat Ratio: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeRatedSensibleHeatRatio(0.971));
+  EXPECT_EQ(0.971, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedSensibleHeatRatio());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeRatedSensibleHeatRatio(-10.0));
+  EXPECT_EQ(0.971, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeRatedSensibleHeatRatio());
+
+  // Cooling And Charge Mode Cooling Rated COP: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeCoolingRatedCOP(3.4));
+  EXPECT_EQ(3.4, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeCoolingRatedCOP());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeCoolingRatedCOP(-10.0));
+  EXPECT_EQ(3.4, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeCoolingRatedCOP());
+
+  // Cooling And Charge Mode Charging Rated COP: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeChargingRatedCOP(3.5));
+  EXPECT_EQ(3.5, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeChargingRatedCOP());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeChargingRatedCOP(-10.0));
+  EXPECT_EQ(3.5, coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeChargingRatedCOP());
+
+  // Cooling And Charge Mode Total Evaporator Cooling Capacity Function of Temperature Curve: Optional Object
+  CurveTriquadratic coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(
+    coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve().get());
+
+  // Cooling And Charge Mode Total Evaporator Cooling Capacity Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(
+    coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve().get());
+
+  // Cooling And Charge Mode Evaporator Energy Input Ratio Function of Temperature Curve: Optional Object
+  CurveTriquadratic coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(
+    coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve().get());
+
+  // Cooling And Charge Mode Evaporator Energy Input Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve().get());
+
+  // Cooling And Charge Mode Evaporator Part Load Fraction Correlation Curve: Optional Object
+  CurveQuadratic coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve(
+    coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve());
+  EXPECT_EQ(coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeEvaporatorPartLoadFractionCorrelationCurve().get());
+
+  // Cooling And Charge Mode Storage Charge Capacity Function of Temperature Curve: Optional Object
+  CurveTriquadratic coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve(
+    coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageChargeCapacityFunctionofTemperatureCurve().get());
+
+  // Cooling And Charge Mode Storage Charge Capacity Function of Total Evaporator PLR Curve: Optional Object
+  CurveQuadratic coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve(
+    coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve());
+  EXPECT_EQ(coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageChargeCapacityFunctionofTotalEvaporatorPLRCurve().get());
+
+  // Cooling And Charge Mode Storage Energy Input Ratio Function of Temperature Curve: Optional Object
+  CurveTriquadratic coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(
+    coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageEnergyInputRatioFunctionofTemperatureCurve().get());
+
+  // Cooling And Charge Mode Storage Energy Input Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve().get());
+
+  // Cooling And Charge Mode Storage Energy Part Load Fraction Correlation Curve: Optional Object
+  CurveQuadratic coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve(
+    coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve());
+  EXPECT_EQ(coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeStorageEnergyPartLoadFractionCorrelationCurve().get());
+
+  // Cooling And Charge Mode Sensible Heat Ratio Function of Temperature Curve: Optional Object
+  CurveBiquadratic coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve(
+    coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeSensibleHeatRatioFunctionofTemperatureCurve().get());
+
+  // Cooling And Charge Mode Sensible Heat Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve(
+    coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndChargeModeSensibleHeatRatioFunctionofFlowFractionCurve().get());
+
+  // Cooling And Discharge Mode Available: Required Boolean
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeAvailable(true));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeAvailable());
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeAvailable(false));
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeAvailable());
+
+  // Cooling And Discharge Mode Rated Total Evaporator Cooling Capacity: Optional Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacityAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity(4.9));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity());
+  EXPECT_EQ(4.9, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity());
+  EXPECT_EQ(4.9, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedTotalEvaporatorCoolingCapacity().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isCoolingAndDischargeModeRatedTotalEvaporatorCoolingCapacityAutosized());
+
+  // Cooling And Discharge Mode Evaporator Capacity Sizing Factor: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeEvaporatorCapacitySizingFactor(5.0));
+  EXPECT_EQ(5.0, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeEvaporatorCapacitySizingFactor());
+
+  // Cooling And Discharge Mode Rated Storage Discharging Capacity: Optional Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeCoolingAndDischargeModeRatedStorageDischargingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isCoolingAndDischargeModeRatedStorageDischargingCapacityAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeRatedStorageDischargingCapacity(5.1));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedStorageDischargingCapacity());
+  EXPECT_EQ(5.1, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedStorageDischargingCapacity().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeRatedStorageDischargingCapacity(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedStorageDischargingCapacity());
+  EXPECT_EQ(5.1, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedStorageDischargingCapacity().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isCoolingAndDischargeModeRatedStorageDischargingCapacityAutosized());
+
+  // Cooling And Discharge Mode Storage Discharge Capacity Sizing Factor: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageDischargeCapacitySizingFactor(5.2));
+  EXPECT_EQ(5.2, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageDischargeCapacitySizingFactor());
+
+  // Cooling And Discharge Mode Rated Sensible Heat Ratio: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeRatedSensibleHeatRatio(0.981));
+  EXPECT_EQ(0.981, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedSensibleHeatRatio());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeRatedSensibleHeatRatio(-10.0));
+  EXPECT_EQ(0.981, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeRatedSensibleHeatRatio());
+
+  // Cooling And Discharge Mode Cooling Rated COP: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeCoolingRatedCOP(5.4));
+  EXPECT_EQ(5.4, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeCoolingRatedCOP());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeCoolingRatedCOP(-10.0));
+  EXPECT_EQ(5.4, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeCoolingRatedCOP());
+
+  // Cooling And Discharge Mode Discharging Rated COP: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeDischargingRatedCOP(5.5));
+  EXPECT_EQ(5.5, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeDischargingRatedCOP());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeDischargingRatedCOP(-10.0));
+  EXPECT_EQ(5.5, coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeDischargingRatedCOP());
+
+  // Cooling And Discharge Mode Total Evaporator Cooling Capacity Function of Temperature Curve: Optional Object
+  CurveTriquadratic coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(
+    coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve().get());
+
+  // Cooling And Discharge Mode Total Evaporator Cooling Capacity Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(
+    coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve().get());
+
+  // Cooling And Discharge Mode Evaporator Energy Input Ratio Function of Temperature Curve: Optional Object
+  CurveTriquadratic coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve(
+    coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofTemperatureCurve().get());
+
+  // Cooling And Discharge Mode Evaporator Energy Input Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeEvaporatorEnergyInputRatioFunctionofFlowFractionCurve().get());
+
+  // Cooling And Discharge Mode Evaporator Part Load Fraction Correlation Curve: Optional Object
+  CurveQuadratic coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve(
+    coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve());
+  EXPECT_EQ(coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeEvaporatorPartLoadFractionCorrelationCurve().get());
+
+  // Cooling And Discharge Mode Storage Discharge Capacity Function of Temperature Curve: Optional Object
+  CurveTriquadratic coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve(
+    coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageDischargeCapacityFunctionofTemperatureCurve().get());
+
+  // Cooling And Discharge Mode Storage Discharge Capacity Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve(
+    coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageDischargeCapacityFunctionofFlowFractionCurve().get());
+
+  // Cooling And Discharge Mode Storage Discharge Capacity Function of Total Evaporator PLR Curve: Optional Object
+  CurveQuadratic coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve(
+    coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve());
+  EXPECT_EQ(coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageDischargeCapacityFunctionofTotalEvaporatorPLRCurve().get());
+
+  // Cooling And Discharge Mode Storage Energy Input Ratio Function of Temperature Curve: Optional Object
+  CurveTriquadratic coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve(
+    coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageEnergyInputRatioFunctionofTemperatureCurve().get());
+
+  // Cooling And Discharge Mode Storage Energy Input Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve(
+    coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageEnergyInputRatioFunctionofFlowFractionCurve().get());
+
+  // Cooling And Discharge Mode Storage Energy Part Load Fraction Correlation Curve: Optional Object
+  CurveQuadratic coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve(
+    coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve());
+  EXPECT_EQ(coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeStorageEnergyPartLoadFractionCorrelationCurve().get());
+
+  // Cooling And Discharge Mode Sensible Heat Ratio Function of Temperature Curve: Optional Object
+  CurveBiquadratic coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve(
+    coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeSensibleHeatRatioFunctionofTemperatureCurve().get());
+
+  // Cooling And Discharge Mode Sensible Heat Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCoolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve(
+    coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.coolingAndDischargeModeSensibleHeatRatioFunctionofFlowFractionCurve().get());
+
+  // Charge Only Mode Available: Required Boolean
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeAvailable(true));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeAvailable());
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeAvailable(false));
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeAvailable());
+
+  // Charge Only Mode Rated Storage Charging Capacity: Optional Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeChargeOnlyModeRatedStorageChargingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isChargeOnlyModeRatedStorageChargingCapacityAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeRatedStorageChargingCapacity(7.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeRatedStorageChargingCapacity());
+  EXPECT_EQ(7.0, coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeRatedStorageChargingCapacity().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeRatedStorageChargingCapacity(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeRatedStorageChargingCapacity());
+  EXPECT_EQ(7.0, coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeRatedStorageChargingCapacity().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isChargeOnlyModeRatedStorageChargingCapacityAutosized());
+
+  // Charge Only Mode Capacity Sizing Factor: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeCapacitySizingFactor(7.1));
+  EXPECT_EQ(7.1, coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeCapacitySizingFactor());
+
+  // Charge Only Mode Charging Rated COP: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeChargingRatedCOP(7.2));
+  EXPECT_EQ(7.2, coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeChargingRatedCOP());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeChargingRatedCOP(-10.0));
+  EXPECT_EQ(7.2, coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeChargingRatedCOP());
+
+  // Charge Only Mode Storage Charge Capacity Function of Temperature Curve: Optional Object
+  CurveBiquadratic chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve(
+    chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve());
+  EXPECT_EQ(chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeStorageChargeCapacityFunctionofTemperatureCurve().get());
+
+  // Charge Only Mode Storage Energy Input Ratio Function of Temperature Curve: Optional Object
+  CurveBiquadratic chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setChargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve(
+    chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.chargeOnlyModeStorageEnergyInputRatioFunctionofTemperatureCurve().get());
+
+  // Discharge Only Mode Available: Required Boolean
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeAvailable(true));
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeAvailable());
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeAvailable(false));
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeAvailable());
+
+  // Discharge Only Mode Rated Storage Discharging Capacity: Optional Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeDischargeOnlyModeRatedStorageDischargingCapacity();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isDischargeOnlyModeRatedStorageDischargingCapacityAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeRatedStorageDischargingCapacity(7.6));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeRatedStorageDischargingCapacity());
+  EXPECT_EQ(7.6, coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeRatedStorageDischargingCapacity().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeRatedStorageDischargingCapacity(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeRatedStorageDischargingCapacity());
+  EXPECT_EQ(7.6, coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeRatedStorageDischargingCapacity().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isDischargeOnlyModeRatedStorageDischargingCapacityAutosized());
+
+  // Discharge Only Mode Capacity Sizing Factor: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeCapacitySizingFactor(7.7));
+  EXPECT_EQ(7.7, coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeCapacitySizingFactor());
+
+  // Discharge Only Mode Rated Sensible Heat Ratio: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeRatedSensibleHeatRatio(0.987));
+  EXPECT_EQ(0.987, coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeRatedSensibleHeatRatio());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeRatedSensibleHeatRatio(-10.0));
+  EXPECT_EQ(0.987, coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeRatedSensibleHeatRatio());
+
+  // Discharge Only Mode Rated COP: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeRatedCOP(7.9));
+  EXPECT_EQ(7.9, coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeRatedCOP());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeRatedCOP(-10.0));
+  EXPECT_EQ(7.9, coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeRatedCOP());
+
+  // Discharge Only Mode Storage Discharge Capacity Function of Temperature Curve: Optional Object
+  CurveBiquadratic dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve(
+    dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve());
+  EXPECT_EQ(dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeStorageDischargeCapacityFunctionofTemperatureCurve().get());
+
+  // Discharge Only Mode Storage Discharge Capacity Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve(
+    dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve());
+  EXPECT_EQ(dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeStorageDischargeCapacityFunctionofFlowFractionCurve().get());
+
+  // Discharge Only Mode Energy Input Ratio Function of Temperature Curve: Optional Object
+  CurveBiquadratic dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve(
+    dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeEnergyInputRatioFunctionofTemperatureCurve().get());
+
+  // Discharge Only Mode Energy Input Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve(
+    dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeEnergyInputRatioFunctionofFlowFractionCurve().get());
+
+  // Discharge Only Mode Part Load Fraction Correlation Curve: Optional Object
+  CurveQuadratic dischargeOnlyModePartLoadFractionCorrelationCurve(m);
+  EXPECT_TRUE(
+    coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModePartLoadFractionCorrelationCurve(dischargeOnlyModePartLoadFractionCorrelationCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModePartLoadFractionCorrelationCurve());
+  EXPECT_EQ(dischargeOnlyModePartLoadFractionCorrelationCurve,
+            coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModePartLoadFractionCorrelationCurve().get());
+
+  // Discharge Only Mode Sensible Heat Ratio Function of Temperature Curve: Optional Object
+  CurveBiquadratic dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve(
+    dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve());
+  EXPECT_EQ(dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve,
+            coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeSensibleHeatRatioFunctionofTemperatureCurve().get());
+
+  // Discharge Only Mode Sensible Heat Ratio Function of Flow Fraction Curve: Optional Object
+  CurveQuadratic dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setDischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve(
+    dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve());
+  EXPECT_EQ(dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve,
+            coilCoolingDXSingleSpeedThermalStorage.dischargeOnlyModeSensibleHeatRatioFunctionofFlowFractionCurve().get());
+
+  // Ancillary Electric Power: Optional Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setAncillaryElectricPower(8.7));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.ancillaryElectricPower());
+  EXPECT_EQ(8.7, coilCoolingDXSingleSpeedThermalStorage.ancillaryElectricPower().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setAncillaryElectricPower(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.ancillaryElectricPower());
+  EXPECT_EQ(8.7, coilCoolingDXSingleSpeedThermalStorage.ancillaryElectricPower().get());
+
+  // Cold Weather Operation Minimum Outdoor Air Temperature: Optional Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setColdWeatherOperationMinimumOutdoorAirTemperature(8.8));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coldWeatherOperationMinimumOutdoorAirTemperature());
+  EXPECT_EQ(8.8, coilCoolingDXSingleSpeedThermalStorage.coldWeatherOperationMinimumOutdoorAirTemperature().get());
+
+  // Cold Weather Operation Ancillary Power: Optional Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setColdWeatherOperationAncillaryPower(8.9));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coldWeatherOperationAncillaryPower());
+  EXPECT_EQ(8.9, coilCoolingDXSingleSpeedThermalStorage.coldWeatherOperationAncillaryPower().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setColdWeatherOperationAncillaryPower(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.coldWeatherOperationAncillaryPower());
+  EXPECT_EQ(8.9, coilCoolingDXSingleSpeedThermalStorage.coldWeatherOperationAncillaryPower().get());
+
+  // Condenser Design Air Flow Rate: Required Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeCondenserDesignAirFlowRate();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isCondenserDesignAirFlowRateAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCondenserDesignAirFlowRate(9.2));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.condenserDesignAirFlowRate());
+  EXPECT_EQ(9.2, coilCoolingDXSingleSpeedThermalStorage.condenserDesignAirFlowRate().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCondenserDesignAirFlowRate(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.condenserDesignAirFlowRate());
+  EXPECT_EQ(9.2, coilCoolingDXSingleSpeedThermalStorage.condenserDesignAirFlowRate().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isCondenserDesignAirFlowRateAutosized());
+
+  // Condenser Air Flow Sizing Factor: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCondenserAirFlowSizingFactor(9.3));
+  EXPECT_EQ(9.3, coilCoolingDXSingleSpeedThermalStorage.condenserAirFlowSizingFactor());
+
+  // Condenser Type: Required String
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCondenserType("AirCooled"));
+  EXPECT_EQ("AirCooled", coilCoolingDXSingleSpeedThermalStorage.condenserType());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setCondenserType("BADENUM"));
+  EXPECT_EQ("AirCooled", coilCoolingDXSingleSpeedThermalStorage.condenserType());
+
+  // Evaporative Condenser Effectiveness: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setEvaporativeCondenserEffectiveness(0.99));
+  EXPECT_EQ(0.99, coilCoolingDXSingleSpeedThermalStorage.evaporativeCondenserEffectiveness());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setEvaporativeCondenserEffectiveness(-10.0));
+  EXPECT_EQ(0.99, coilCoolingDXSingleSpeedThermalStorage.evaporativeCondenserEffectiveness());
+
+  // Evaporative Condenser Pump Rated Power Consumption: Required Double
+  // Autosize
+  coilCoolingDXSingleSpeedThermalStorage.autosizeEvaporativeCondenserPumpRatedPowerConsumption();
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.isEvaporativeCondenserPumpRatedPowerConsumptionAutosized());
+  // Set
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setEvaporativeCondenserPumpRatedPowerConsumption(9.6));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.evaporativeCondenserPumpRatedPowerConsumption());
+  EXPECT_EQ(9.6, coilCoolingDXSingleSpeedThermalStorage.evaporativeCondenserPumpRatedPowerConsumption().get());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setEvaporativeCondenserPumpRatedPowerConsumption(-10.0));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.evaporativeCondenserPumpRatedPowerConsumption());
+  EXPECT_EQ(9.6, coilCoolingDXSingleSpeedThermalStorage.evaporativeCondenserPumpRatedPowerConsumption().get());
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.isEvaporativeCondenserPumpRatedPowerConsumptionAutosized());
+
+  // Basin Heater Capacity: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setBasinHeaterCapacity(9.7));
+  EXPECT_EQ(9.7, coilCoolingDXSingleSpeedThermalStorage.basinHeaterCapacity());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setBasinHeaterCapacity(-10.0));
+  EXPECT_EQ(9.7, coilCoolingDXSingleSpeedThermalStorage.basinHeaterCapacity());
+
+  // Basin Heater Setpoint Temperature: Required Double
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setBasinHeaterSetpointTemperature(11.8));
+  EXPECT_EQ(11.8, coilCoolingDXSingleSpeedThermalStorage.basinHeaterSetpointTemperature());
+  // Bad Value
+  EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setBasinHeaterSetpointTemperature(-8.0));
+  EXPECT_EQ(11.8, coilCoolingDXSingleSpeedThermalStorage.basinHeaterSetpointTemperature());
+
+  // Basin Heater Availability Schedule: Optional Object
+  ScheduleConstant basinHeaterAvailabilitySchedule(m);
+  EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setBasinHeaterAvailabilitySchedule(basinHeaterAvailabilitySchedule));
+  ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.basinHeaterAvailabilitySchedule());
+  EXPECT_EQ(basinHeaterAvailabilitySchedule, coilCoolingDXSingleSpeedThermalStorage.basinHeaterAvailabilitySchedule().get());
+
+  // Supply Water Storage Tank: Optional Object
+  // boost::optional<WaterStorageTank> supplyWaterStorageTank(m);
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setSupplyWaterStorageTank(supplyWaterStorageTank));
+  // ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.supplyWaterStorageTank());
+  // EXPECT_EQ(supplyWaterStorageTank, coilCoolingDXSingleSpeedThermalStorage.supplyWaterStorageTank().get());
+
+  // Condensate Collection Water Storage Tank: Optional Object
+  // boost::optional<WaterStorageTank> condensateCollectionWaterStorageTank(m);
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setCondensateCollectionWaterStorageTank(condensateCollectionWaterStorageTank));
+  // ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.condensateCollectionWaterStorageTank());
+  // EXPECT_EQ(condensateCollectionWaterStorageTank, coilCoolingDXSingleSpeedThermalStorage.condensateCollectionWaterStorageTank().get());
+
+  // Storage Tank Plant Connection Design Flow Rate: Optional Double
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankPlantConnectionDesignFlowRate(10.4));
+  // ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.storageTankPlantConnectionDesignFlowRate());
+  // EXPECT_EQ(10.4, coilCoolingDXSingleSpeedThermalStorage.storageTankPlantConnectionDesignFlowRate().get());
+  // Bad Value
+  // EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankPlantConnectionDesignFlowRate(-10.0));
+  // ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.storageTankPlantConnectionDesignFlowRate());
+  // EXPECT_EQ(10.4, coilCoolingDXSingleSpeedThermalStorage.storageTankPlantConnectionDesignFlowRate().get());
+
+  // Storage Tank Plant Connection Heat Transfer Effectiveness: Required Double
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankPlantConnectionHeatTransferEffectiveness(0.991));
+  // EXPECT_EQ(0.991, coilCoolingDXSingleSpeedThermalStorage.storageTankPlantConnectionHeatTransferEffectiveness());
+  // Bad Value
+  // EXPECT_FALSE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankPlantConnectionHeatTransferEffectiveness(-10.0));
+  // EXPECT_EQ(0.991, coilCoolingDXSingleSpeedThermalStorage.storageTankPlantConnectionHeatTransferEffectiveness());
+
+  // Storage Tank Minimum Operating Limit Fluid Temperature: Optional Double
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankMinimumOperatingLimitFluidTemperature(10.6));
+  // ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.storageTankMinimumOperatingLimitFluidTemperature());
+  // EXPECT_EQ(10.6, coilCoolingDXSingleSpeedThermalStorage.storageTankMinimumOperatingLimitFluidTemperature().get());
+
+  // Storage Tank Maximum Operating Limit Fluid Temperature: Optional Double
+  // EXPECT_TRUE(coilCoolingDXSingleSpeedThermalStorage.setStorageTankMaximumOperatingLimitFluidTemperature(10.7));
+  // ASSERT_TRUE(coilCoolingDXSingleSpeedThermalStorage.storageTankMaximumOperatingLimitFluidTemperature());
+  // EXPECT_EQ(10.7, coilCoolingDXSingleSpeedThermalStorage.storageTankMaximumOperatingLimitFluidTemperature().get());
+}
+TEST_F(ModelFixture, CoilCoolingDXSingleSpeedThermalStorage_HeatCoolFuelTypes) {
+  Model m;
+
+  CoilCoolingDXSingleSpeedThermalStorage coilCoolingDXSingleSpeedThermalStorage(m);
+
+  EXPECT_EQ(ComponentType(ComponentType::Cooling), coilCoolingDXSingleSpeedThermalStorage.componentType());
+  testFuelTypeEquality({FuelType::Electricity}, coilCoolingDXSingleSpeedThermalStorage.coolingFuelTypes());
+  testFuelTypeEquality({}, coilCoolingDXSingleSpeedThermalStorage.heatingFuelTypes());
+  testAppGFuelTypeEquality({}, coilCoolingDXSingleSpeedThermalStorage.appGHeatingFuelTypes());
+}
+
+TEST_F(ModelFixture, CoilCoolingDXSingleSpeedThermalStorage_containingHVACComponent) {
+  {  // AirLoopHVACUnitarySystem
+    Model model;
+
+    CoilCoolingDXSingleSpeedThermalStorage dx(model);
+    EXPECT_TRUE(dx.isRemovable());
+
+    AirLoopHVACUnitarySystem unitary(model);
+    EXPECT_TRUE(unitary.setCoolingCoil(dx));
+    ASSERT_TRUE(unitary.coolingCoil());
+    EXPECT_EQ(dx, unitary.coolingCoil().get());
+
+    ASSERT_TRUE(dx.containingHVACComponent());
+    EXPECT_EQ(unitary, dx.containingHVACComponent().get());
+
+    // Shouldn't be able to remove DX since it's contained in a HVAC Component
+    EXPECT_FALSE(dx.isRemovable());
+    auto rmed = dx.remove();
+    EXPECT_EQ(0u, rmed.size());
+    ASSERT_TRUE(unitary.coolingCoil());
+    EXPECT_EQ(dx, unitary.coolingCoil().get());
+  }
+}
+
+TEST_F(ModelFixture, CoilCoolingDXSingleSpeedThermalStorage_addToNode) {
+  Model m;
+
+  CoilCoolingDXSingleSpeedThermalStorage dx(m);
+
+  AirLoopHVAC airLoop(m);
+
+  Node supplyOutletNode = airLoop.supplyOutletNode();
+  EXPECT_FALSE(dx.airLoopHVAC());
+  EXPECT_EQ((unsigned)2, airLoop.supplyComponents().size());
+  EXPECT_TRUE(dx.addToNode(supplyOutletNode));
+  EXPECT_EQ((unsigned)3, airLoop.supplyComponents().size());
+  EXPECT_TRUE(dx.airLoopHVAC());
+
+  Node demandNode = airLoop.zoneSplitter().lastOutletModelObject()->cast<Node>();
+  EXPECT_FALSE(dx.addToNode(demandNode));
+  // 5u: inlet splitter node mixer outlet.
+  EXPECT_EQ((unsigned)5, airLoop.demandComponents().size());
+  EXPECT_EQ((unsigned)3, airLoop.supplyComponents().size());
+  EXPECT_TRUE(dx.airLoopHVAC());
+
+  EXPECT_TRUE(dx.removeFromLoop());
+  EXPECT_EQ((unsigned)2, airLoop.supplyComponents().size());
+  EXPECT_FALSE(dx.airLoopHVAC());
+
+  PlantLoop plantLoop(m);
+  supplyOutletNode = plantLoop.supplyOutletNode();
+  EXPECT_FALSE(dx.addToNode(supplyOutletNode));
+  EXPECT_EQ((unsigned)5, plantLoop.supplyComponents().size());
+
+  Node demandOutletNode = plantLoop.demandOutletNode();
+  EXPECT_FALSE(dx.addToNode(demandOutletNode));
+  EXPECT_EQ((unsigned)5, plantLoop.demandComponents().size());
+}
+
+TEST_F(ModelFixture, CoilCoolingDXSingleSpeedThermalStorage_clone) {
+  Model model;
+
+  EXPECT_EQ(0, model.getModelObjects<Curve>().size());
+  EXPECT_EQ(0, model.getConcreteModelObjects<CurveBiquadratic>().size());
+  EXPECT_EQ(0, model.getConcreteModelObjects<CurveQuadratic>().size());
+  EXPECT_EQ(0, model.getConcreteModelObjects<CurveTriquadratic>().size());
+  EXPECT_EQ(0, model.getConcreteModelObjects<CoilCoolingDXSingleSpeedThermalStorage>().size());
+
+  CoilCoolingDXSingleSpeedThermalStorage dx(model);
+  CurveBiquadratic curve1(model);
+  EXPECT_TRUE(dx.setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(curve1));
+  CurveQuadratic curve2(model);
+  EXPECT_TRUE(dx.setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofFlowFractionCurve(curve2));
+  CurveTriquadratic curve3(model);
+  EXPECT_TRUE(dx.setCoolingAndChargeModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(curve3));
+
+  {
+    EXPECT_EQ(3, model.getModelObjects<Curve>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CurveQuadratic>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CurveTriquadratic>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CoilCoolingDXSingleSpeedThermalStorage>().size());
+
+    EXPECT_TRUE(dx.setStorageType("Water"));
+  }
+
+  auto dxClone = dx.clone(model).cast<CoilCoolingDXSingleSpeedThermalStorage>();
+  {
+    EXPECT_EQ("Water", dxClone.storageType());
+
+    EXPECT_EQ(3, model.getModelObjects<Curve>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CurveQuadratic>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CurveTriquadratic>().size());
+    EXPECT_EQ(2, model.getConcreteModelObjects<CoilCoolingDXSingleSpeedThermalStorage>().size());
+  }
+
+  {
+    Model model2;
+
+    EXPECT_EQ(0, model2.getModelObjects<Curve>().size());
+    EXPECT_EQ(0, model2.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(0, model2.getConcreteModelObjects<CurveQuadratic>().size());
+    EXPECT_EQ(0, model2.getConcreteModelObjects<CurveTriquadratic>().size());
+    EXPECT_EQ(0, model2.getConcreteModelObjects<CoilCoolingDXSingleSpeedThermalStorage>().size());
+
+    auto dxClone2 = dx.clone(model2).cast<CoilCoolingDXSingleSpeedThermalStorage>();
+
+    EXPECT_EQ("Water", dxClone2.storageType());
+
+    EXPECT_EQ(3, model2.getModelObjects<Curve>().size());
+    EXPECT_EQ(1, model2.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(1, model2.getConcreteModelObjects<CurveQuadratic>().size());
+    EXPECT_EQ(1, model2.getConcreteModelObjects<CurveTriquadratic>().size());
+    EXPECT_EQ(1, model2.getConcreteModelObjects<CoilCoolingDXSingleSpeedThermalStorage>().size());
+  }
+
+  {
+    dx.remove();
+    EXPECT_EQ(3, model.getModelObjects<Curve>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CurveQuadratic>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CurveTriquadratic>().size());
+    EXPECT_EQ(1, model.getConcreteModelObjects<CoilCoolingDXSingleSpeedThermalStorage>().size());
+
+    dxClone.remove();
+    EXPECT_EQ(0, model.getModelObjects<Curve>().size());
+    EXPECT_EQ(0, model.getConcreteModelObjects<CurveBiquadratic>().size());
+    EXPECT_EQ(0, model.getConcreteModelObjects<CurveQuadratic>().size());
+    EXPECT_EQ(0, model.getConcreteModelObjects<CurveTriquadratic>().size());
+    EXPECT_EQ(0, model.getConcreteModelObjects<CoilCoolingDXSingleSpeedThermalStorage>().size());
+  }
+}
+
+TEST_F(ModelFixture, CoilCoolingDXSingleSpeedThermalStorage_cloneParent) {
+  Model model;
+
+  CoilCoolingDXSingleSpeedThermalStorage dx(model);
+  CurveBiquadratic curve1(model);
+  EXPECT_TRUE(dx.setCoolingOnlyModeTotalEvaporatorCoolingCapacityFunctionofTemperatureCurve(curve1));
+
+  AirLoopHVACUnitarySystem unitary(model);
+  EXPECT_TRUE(unitary.setCoolingCoil(dx));
+
+  ASSERT_TRUE(dx.containingHVACComponent());
+  EXPECT_EQ(unitary, dx.containingHVACComponent().get());
+
+  ASSERT_TRUE(unitary.coolingCoil());
+  EXPECT_EQ(dx, unitary.coolingCoil().get());
+
+  EXPECT_EQ(1u, model.getConcreteModelObjects<AirLoopHVACUnitarySystem>().size());
+  EXPECT_EQ(1u, model.getConcreteModelObjects<CoilCoolingDXSingleSpeedThermalStorage>().size());
+  EXPECT_EQ(1u, model.getConcreteModelObjects<CurveBiquadratic>().size());
+
+  // Cloning the unitary should clone the coolingCoil, but the clone of the DX should still share resources
+  auto unitaryClone = unitary.clone(model).cast<AirLoopHVACUnitarySystem>();
+  EXPECT_EQ(2u, model.getConcreteModelObjects<AirLoopHVACUnitarySystem>().size());
+  EXPECT_EQ(2u, model.getConcreteModelObjects<CoilCoolingDXSingleSpeedThermalStorage>().size());
+  EXPECT_EQ(1u, model.getConcreteModelObjects<CurveBiquadratic>().size());
+  EXPECT_EQ(dx, unitary.coolingCoil().get());
+  EXPECT_NE(dx, unitaryClone.coolingCoil().get());
+}