Repository: NREL/OpenStudio (language: python)

Issue:
API breaking changes to consider
Enhancement Request
--------------

This is meant as a running list of API breaking changes we should consider for a future version.


## Detailed Description

### Getters returning an optional<X> when there is a default in the IDD, or when there is a Ctor harcoded value and no `reset`

- [ ] CoilCoolingDXSingleSpeed: ratedCOP, ratedEvaporatorFanPowerPerVolumeFlowRate, and others return an optional<double> when it should be a double.  The IDD has a default **AND** the ctor still hardcodes the same default... AND there isn't a `reset` function either... 
https://github.com/NREL/OpenStudio/blob/7801af2670f7fdf4f0ea71d9a3288d4bbe256065/src/model/CoilCoolingDXSingleSpeed.hpp#L92-L96
   - ratedCOP
   - ratedEvaporatorFanPowerPerVolumeFlowRate
   - nominalTimeForCondensateRemovalToBegin
   - ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity
   - maximumCyclingRate
   - latentCapacityTimeConstant
   - evaporativeCondenserEffectiveness
   - crankcaseHeaterCapacity
   - maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation
   - basinHeaterCapacity
   - basinHeaterSetpointTemperature
   - **Should we just make all these required-field so we don't need `reset` and `isDefaulted` methods?** Same for CoilCoolingDXTwoSpeed below.

- [ ] CoilCoolingDXTwoSpeed
   - ratedHighSpeedCOP
   - ratedLowSpeedCOP
   - highSpeedEvaporativeCondenserEffectiveness
   - lowSpeedEvaporativeCondenserEffectiveness
   - basinHeaterCapacity (sets a different value between ctors)
   - basinHeaterSetpointTemperature (sets a different value between ctors)

- [x] EvaporativeFluidCooler:SingleSpeed
    - performanceInputMethod (make required-field, and change boost::optional<std::string> to std::string)
    - Cf  #4642

### Others



Discussion / hints:

Fix patch:
diff --git a/developer/doc/ReleaseNotes/OpenStudio_Release_Notes_3_4_1_TBD.md b/developer/doc/ReleaseNotes/OpenStudio_Release_Notes_3_4_1_TBD.md
index 6b5d9e10755..0be002fae03 100644
--- a/developer/doc/ReleaseNotes/OpenStudio_Release_Notes_3_4_1_TBD.md
+++ b/developer/doc/ReleaseNotes/OpenStudio_Release_Notes_3_4_1_TBD.md
@@ -72,6 +72,8 @@ You can also refer to the [OpenStudio SDK Python Binding Version Compatibility M
     * `Chiller:Electric:EIR` has a few API-breaking changes related to its Curves. The types for the constructor, getters and setters used to be explicit (eg: `CurveBiquadratic`): it is now the base class, more generic, `Curve` type for added flexibility.
 * [#4642](https://github.com/NREL/OpenStudio/pull/4642) - Addresses #4575, API change for EvaporativeCoolerFluid:SingleSpeed
     * `EvaporativeCoolerFluid:SingleSpeed` has an API-breaking change related to its `performanceInputMethod` getter. It is now a required field that returns `std::string` instead of `boost::optional<std::string>`.
+* [#4644](https://github.com/NREL/OpenStudio/pull/4644) - Addresses #4575, API change for Coil:Cooling:DX:SingleSpeed and Coil:Cooling:DX:TwoSpeed
+    * ` Coil:Cooling:DX:SingleSpeed` and `Coil:Cooling:DX:TwoSpeed` have API-breaking changes related to many of their getters. They are now required fields that return `double` instead of `boost::optional<double>`. Also removes many deprecated methods.
 
 
 ## Minor changes and bug fixes
diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd
index 46ff7922133..b5fe0160b82 100644
--- a/resources/model/OpenStudio.idd
+++ b/resources/model/OpenStudio.idd
@@ -16164,7 +16164,7 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \type real
        \units W/W
        \minimum> 0
-       \default 3.0
+       \required-field
   N4, \field Rated Air Flow Rate
        \note Flow rate corresponding to rated total cooling capacity, Rated SHR and Rated COP
        \note should be between 0.00004027 m3/s and .00006041 m3/s per watt of rated total cooling capacity
@@ -16184,7 +16184,7 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \units W/(m3/s)
        \minimum 0
        \maximum 1250
-       \default 773.3
+       \required-field
   A4, \field Air Inlet Node Name
        \type object-list
        \required-field
@@ -16242,7 +16242,7 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \units s
        \minimum 0
        \maximum 3000
-       \default 0.0
+       \required-field
   N8, \field Ratio of Initial Moisture Evaporation Rate and Steady State Latent Capacity
        \note Ratio of the initial moisture evaporation rate from the cooling coil (when
        \note the compressor first turns off) and the coil's steady state latent capacity
@@ -16252,7 +16252,7 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \units dimensionless
        \minimum 0
        \maximum 5
-       \default 0.0
+       \required-field
   N9, \field Maximum Cycling Rate
        \note The maximum on-off cycling Rate for the compressor, which occurs at 50% run time
        \note fraction. Suggested value is 3; zero value means latent degradation model is disabled.
@@ -16260,7 +16260,7 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \units cycles/hr
        \minimum 0
        \maximum 5
-       \default 0.0
+       \required-field
   N10, \field Latent Capacity Time Constant
        \note Time constant for the cooling coil's latent capacity to reach steady state after
        \note startup. Suggested value is 45; zero value means latent degradation model is disabled.
@@ -16268,14 +16268,14 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \units s
        \minimum 0
        \maximum 500
-       \default 0.0
+       \required-field
   A11, \field Condenser Air Inlet Node Name
        \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
   A12, \field Condenser Type
        \type choice
-       \default AirCooled
+       \required-field
        \key AirCooled
        \key EvaporativelyCooled
   N11, \field Evaporative Condenser Effectiveness
@@ -16283,7 +16283,7 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \units dimensionless
        \minimum 0
        \maximum 1
-       \default 0.9
+       \required-field
   N12, \field Evaporative Condenser Air Flow Rate
        \note Used to calculate evaporative condenser water use
        \type real
@@ -16302,12 +16302,12 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \units W
        \ip-units Btu/h
        \minimum 0
-       \default 0.0
+       \required-field
   N15, \field Maximum Outdoor Dry-Bulb Temperature for Crankcase Heater Operation
        \type real
        \units C
        \minimum 0
-       \default 10.0
+       \required-field
   A13, \field Supply Water Storage Tank Name
        \type object-list
        \object-list WaterStorageTankNames
@@ -16323,14 +16323,14 @@ OS:Coil:Cooling:DX:SingleSpeed,
        \type real
        \units W/K
        \minimum 0
-       \default 0.0
+       \required-field
   N17, \field Basin Heater Setpoint Temperature
        \note This field is only used for Condenser Type = EvaporativelyCooled.
        \note Enter the outdoor dry-bulb temperature when the basin heater turns on.
        \type real
        \units C
        \minimum 2
-       \default 2.0
+       \required-field
   A15; \field Basin Heater Operating Schedule Name
        \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
@@ -16863,7 +16863,7 @@ OS:Coil:Cooling:DX:TwoSpeed,
        \type real
        \units W/W
        \minimum> 0
-       \default 3.0
+       \required-field
   N4, \field Rated High Speed Air Flow Rate
        \note Flow rate corresponding to rated total cooling capacity, Rated SHR
        \note and Rated COP. Should be between 0.00004027 m3/s and .00006041 m3/s per watt
@@ -16949,7 +16949,7 @@ OS:Coil:Cooling:DX:TwoSpeed,
        \type real
        \units W/W
        \minimum> 0
-       \default 3.0
+       \required-field
   N9, \field Rated Low Speed Air Flow Rate
        \note Flow rate corresponding to rated total cooling capacity, Rated SHR
        \note and Rated COP. Should be between 0.00004027 m3/s and .00006041 m3/s per watt
@@ -16991,7 +16991,7 @@ OS:Coil:Cooling:DX:TwoSpeed,
        \units dimensionless
        \minimum 0
        \maximum 1
-       \default 0.9
+       \required-field
   N12, \field High Speed Evaporative Condenser Air Flow Rate
        \note Used to calculate evaporative condenser water use
        \type real
@@ -17010,7 +17010,7 @@ OS:Coil:Cooling:DX:TwoSpeed,
        \units dimensionless
        \minimum 0
        \maximum 1
-       \default 0.9
+       \required-field
   N15, \field Low Speed Evaporative Condenser Air Flow Rate
        \note Used to calculate evaporative condenser water use
        \type real
@@ -17039,14 +17039,14 @@ OS:Coil:Cooling:DX:TwoSpeed,
        \type real
        \units W/K
        \minimum 0
-       \default 0.0
+       \required-field
   N18, \field Basin Heater Setpoint Temperature
        \note This field is only used for Condenser Type = EvaporativelyCooled.
        \note Enter the outdoor dry-bulb temperature when the basin heater turns on.
        \type real
        \units C
        \minimum 2
-       \default 2.0
+       \required-field
   A17; \field Basin Heater Operating Schedule Name
        \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
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXSingleSpeed.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXSingleSpeed.cpp
index 380e3a2a09f..09c8eba1bd8 100644
--- a/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXSingleSpeed.cpp
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXSingleSpeed.cpp
@@ -61,27 +61,27 @@ namespace energyplus {
 
     // hook up required objects
     try {
-      Schedule sched = modelObject.getAvailabilitySchedule();
+      Schedule sched = modelObject.availabilitySchedule();
       translateAndMapModelObject(sched);
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::AvailabilityScheduleName, sched.name().get());
 
-      Curve cb = modelObject.getTotalCoolingCapacityFunctionOfTemperatureCurve();
+      Curve cb = modelObject.totalCoolingCapacityFunctionOfTemperatureCurve();
       translateAndMapModelObject(cb);
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::TotalCoolingCapacityFunctionofTemperatureCurveName, cb.name().get());
 
-      Curve cq = modelObject.getTotalCoolingCapacityFunctionOfFlowFractionCurve();
+      Curve cq = modelObject.totalCoolingCapacityFunctionOfFlowFractionCurve();
       translateAndMapModelObject(cq);
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::TotalCoolingCapacityFunctionofFlowFractionCurveName, cq.name().get());
 
-      cb = modelObject.getEnergyInputRatioFunctionOfTemperatureCurve();
+      cb = modelObject.energyInputRatioFunctionOfTemperatureCurve();
       translateAndMapModelObject(cb);
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::EnergyInputRatioFunctionofTemperatureCurveName, cb.name().get());
 
-      cq = modelObject.getEnergyInputRatioFunctionOfFlowFractionCurve();
+      cq = modelObject.energyInputRatioFunctionOfFlowFractionCurve();
       translateAndMapModelObject(cq);
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::EnergyInputRatioFunctionofFlowFractionCurveName, cq.name().get());
 
-      cq = modelObject.getPartLoadFractionCorrelationCurve();
+      cq = modelObject.partLoadFractionCorrelationCurve();
       translateAndMapModelObject(cq);
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::PartLoadFractionCorrelationCurveName, cq.name().get());
     } catch (std::exception& e) {
@@ -103,7 +103,7 @@ namespace energyplus {
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::GrossRatedSensibleHeatRatio, "Autosize");
     }
 
-    d = modelObject.getRatedCOP();
+    d = modelObject.ratedCOP();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::GrossRatedCoolingCOP, *d);
     }
@@ -115,7 +115,7 @@ namespace energyplus {
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::RatedAirFlowRate, "Autosize");
     }
 
-    d = modelObject.getRatedEvaporatorFanPowerPerVolumeFlowRate();
+    d = modelObject.ratedEvaporatorFanPowerPerVolumeFlowRate();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::RatedEvaporatorFanPowerPerVolumeFlowRate, *d);
     }
@@ -138,7 +138,7 @@ namespace energyplus {
       }
     }
 
-    d = modelObject.getNominalTimeForCondensateRemovalToBegin();
+    d = modelObject.nominalTimeForCondensateRemovalToBegin();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::NominalTimeforCondensateRemovaltoBegin, *d);
     }
@@ -146,53 +146,53 @@ namespace energyplus {
     idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::MinimumOutdoorDryBulbTemperatureforCompressorOperation,
                         modelObject.minimumOutdoorDryBulbTemperatureforCompressorOperation());
 
-    d = modelObject.getRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity();
+    d = modelObject.ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::RatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity, *d);
     }
 
-    d = modelObject.getMaximumCyclingRate();
+    d = modelObject.maximumCyclingRate();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::MaximumCyclingRate, *d);
     }
 
-    d = modelObject.getLatentCapacityTimeConstant();
+    d = modelObject.latentCapacityTimeConstant();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::LatentCapacityTimeConstant, *d);
     }
 
-    s = modelObject.getCondenserAirInletNodeName();
+    s = modelObject.condenserAirInletNodeName();
     if (s) {
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::CondenserAirInletNodeName, *s);
     }
 
-    idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::CondenserType, modelObject.getCondenserType());
+    idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::CondenserType, modelObject.condenserType());
 
-    d = modelObject.getEvaporativeCondenserEffectiveness();
+    d = modelObject.evaporativeCondenserEffectiveness();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserEffectiveness, *d);
     }
 
-    d = modelObject.getEvaporativeCondenserAirFlowRate();
+    d = modelObject.evaporativeCondenserAirFlowRate();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserAirFlowRate, *d);
     } else {
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserAirFlowRate, "Autosize");
     }
 
-    d = modelObject.getEvaporativeCondenserPumpRatedPowerConsumption();
+    d = modelObject.evaporativeCondenserPumpRatedPowerConsumption();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserPumpRatedPowerConsumption, *d);
     } else {
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserPumpRatedPowerConsumption, "Autosize");
     }
 
-    d = modelObject.getCrankcaseHeaterCapacity();
+    d = modelObject.crankcaseHeaterCapacity();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::CrankcaseHeaterCapacity, *d);
     }
 
-    d = modelObject.getMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation();
+    d = modelObject.maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::MaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation, *d);
     }
@@ -201,17 +201,17 @@ namespace energyplus {
     //getSupplyWaterStorageTankName
     //getCondensateCollectionWaterStorageTankName
 
-    d = modelObject.getBasinHeaterCapacity();
+    d = modelObject.basinHeaterCapacity();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::BasinHeaterCapacity, *d);
     }
 
-    d = modelObject.getBasinHeaterSetpointTemperature();
+    d = modelObject.basinHeaterSetpointTemperature();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_SingleSpeedFields::BasinHeaterSetpointTemperature, *d);
     }
 
-    OptionalSchedule os = modelObject.getBasinHeaterOperatingSchedule();
+    OptionalSchedule os = modelObject.basinHeaterOperatingSchedule();
     if (os) {
       translateAndMapModelObject(*os);
       idfObject.setString(Coil_Cooling_DX_SingleSpeedFields::BasinHeaterOperatingScheduleName, os->name().get());
@@ -245,7 +245,7 @@ namespace energyplus {
       coilSystemCoolingDXIdf.setName(*s + " CoilSystem");
     }
 
-    Schedule sched = modelObject.getAvailabilitySchedule();
+    Schedule sched = modelObject.availabilitySchedule();
     translateAndMapModelObject(sched);
 
     coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::AvailabilityScheduleName, sched.name().get());
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXTwoSpeed.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXTwoSpeed.cpp
index 64d48d07da0..dbe76af9ec6 100644
--- a/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXTwoSpeed.cpp
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateCoilCoolingDXTwoSpeed.cpp
@@ -67,12 +67,12 @@ namespace energyplus {
     }
 
     //  A2 , \field Availability Schedule Name
-    Schedule sched = modelObject.getAvailabilitySchedule();
+    Schedule sched = modelObject.availabilitySchedule();
     translateAndMapModelObject(sched);
     idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::AvailabilityScheduleName, sched.name().get());
 
     //  N1 , \field Rated High Speed Total Cooling Capacity
-    d = modelObject.getRatedHighSpeedTotalCoolingCapacity();
+    d = modelObject.ratedHighSpeedTotalCoolingCapacity();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedGrossRatedTotalCoolingCapacity, *d);
     } else {
@@ -80,7 +80,7 @@ namespace energyplus {
     }
 
     //  N2 , \field Rated High Speed Sensible Heat Ratio
-    d = modelObject.getRatedHighSpeedSensibleHeatRatio();
+    d = modelObject.ratedHighSpeedSensibleHeatRatio();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedRatedSensibleHeatRatio, *d);
     } else {
@@ -88,13 +88,13 @@ namespace energyplus {
     }
 
     //  N3 , \field Rated High Speed COP
-    d = modelObject.getRatedHighSpeedCOP();
+    d = modelObject.ratedHighSpeedCOP();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedGrossRatedCoolingCOP, *d);
     }
 
     //  N4 , \field Rated High Speed Air Flow Rate
-    d = modelObject.getRatedHighSpeedAirFlowRate();
+    d = modelObject.ratedHighSpeedAirFlowRate();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedRatedAirFlowRate, *d);
     } else {
@@ -128,32 +128,32 @@ namespace energyplus {
     }
 
     //  A5 , \field Total Cooling Capacity Function of Temperature Curve Name
-    Curve cb = modelObject.getTotalCoolingCapacityFunctionOfTemperatureCurve();
+    Curve cb = modelObject.totalCoolingCapacityFunctionOfTemperatureCurve();
     translateAndMapModelObject(cb);
     idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::TotalCoolingCapacityFunctionofTemperatureCurveName, cb.name().get());
 
     //  A6 , \field Total Cooling Capacity Function of Flow Fraction Curve Name
-    cb = modelObject.getTotalCoolingCapacityFunctionOfFlowFractionCurve();
+    cb = modelObject.totalCoolingCapacityFunctionOfFlowFractionCurve();
     translateAndMapModelObject(cb);
     idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::TotalCoolingCapacityFunctionofFlowFractionCurveName, cb.name().get());
 
     //  A7 , \field Energy Input Ratio Function of Temperature Curve Name
-    cb = modelObject.getEnergyInputRatioFunctionOfTemperatureCurve();
+    cb = modelObject.energyInputRatioFunctionOfTemperatureCurve();
     translateAndMapModelObject(cb);
     idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::EnergyInputRatioFunctionofTemperatureCurveName, cb.name().get());
 
     //  A8 , \field Energy Input Ratio Function of Flow Fraction Curve Name
-    Curve cq = modelObject.getEnergyInputRatioFunctionOfFlowFractionCurve();
+    Curve cq = modelObject.energyInputRatioFunctionOfFlowFractionCurve();
     translateAndMapModelObject(cq);
     idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::EnergyInputRatioFunctionofFlowFractionCurveName, cq.name().get());
 
     //  A9 , \field Part Load Fraction Correlation Curve Name
-    cq = modelObject.getPartLoadFractionCorrelationCurve();
+    cq = modelObject.partLoadFractionCorrelationCurve();
     translateAndMapModelObject(cq);
     idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::PartLoadFractionCorrelationCurveName, cq.name().get());
 
     //  N5 , \field Rated Low Speed Total Cooling Capacity
-    d = modelObject.getRatedLowSpeedTotalCoolingCapacity();
+    d = modelObject.ratedLowSpeedTotalCoolingCapacity();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedGrossRatedTotalCoolingCapacity, *d);
     } else {
@@ -161,7 +161,7 @@ namespace energyplus {
     }
 
     //  N6 , \field Rated Low Speed Sensible Heat Ratio
-    d = modelObject.getRatedLowSpeedSensibleHeatRatio();
+    d = modelObject.ratedLowSpeedSensibleHeatRatio();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedGrossRatedSensibleHeatRatio, *d);
     } else {
@@ -169,13 +169,13 @@ namespace energyplus {
     }
 
     //  N7 , \field Rated Low Speed COP
-    d = modelObject.getRatedLowSpeedCOP();
+    d = modelObject.ratedLowSpeedCOP();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedGrossRatedCoolingCOP, *d);
     }
 
     //  N8 , \field Rated Low Speed Air Flow Rate
-    d = modelObject.getRatedLowSpeedAirFlowRate();
+    d = modelObject.ratedLowSpeedAirFlowRate();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedRatedAirFlowRate, *d);
     } else {
@@ -183,23 +183,23 @@ namespace energyplus {
     }
 
     //  A10, \field Low Speed Total Cooling Capacity Function of Temperature Curve Name
-    cq = modelObject.getLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve();
+    cq = modelObject.lowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve();
     translateAndMapModelObject(cq);
     idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::LowSpeedTotalCoolingCapacityFunctionofTemperatureCurveName, cq.name().get());
 
     //  A11, \field Low Speed Energy Input Ratio Function of Temperature Curve Name
-    cq = modelObject.getLowSpeedEnergyInputRatioFunctionOfTemperatureCurve();
+    cq = modelObject.lowSpeedEnergyInputRatioFunctionOfTemperatureCurve();
     translateAndMapModelObject(cq);
     idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::LowSpeedEnergyInputRatioFunctionofTemperatureCurveName, cq.name().get());
 
     //  A12, \field Condenser Air Inlet Node Name
-    s = modelObject.getCondenserAirInletNodeName();
+    s = modelObject.condenserAirInletNodeName();
     if (s) {
       idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::CondenserAirInletNodeName, *s);
     }
 
     //  A13, \field Condenser Type
-    idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::CondenserType, modelObject.getCondenserType());
+    idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::CondenserType, modelObject.condenserType());
 
     // Minimum Outdoor Dry-Bulb Temperature for Compressor Operation
     {
@@ -208,13 +208,13 @@ namespace energyplus {
     }
 
     //   N9, \field High Speed Evaporative Condenser Effectiveness
-    d = modelObject.getHighSpeedEvaporativeCondenserEffectiveness();
+    d = modelObject.highSpeedEvaporativeCondenserEffectiveness();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserEffectiveness, *d);
     }
 
     //  N10, \field High Speed Evaporative Condenser Air Flow Rate
-    d = modelObject.getHighSpeedEvaporativeCondenserAirFlowRate();
+    d = modelObject.highSpeedEvaporativeCondenserAirFlowRate();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserAirFlowRate, *d);
     } else {
@@ -222,7 +222,7 @@ namespace energyplus {
     }
 
     //  N11, \field High Speed Evaporative Condenser Pump Rated Power Consumption
-    d = modelObject.getHighSpeedEvaporativeCondenserPumpRatedPowerConsumption();
+    d = modelObject.highSpeedEvaporativeCondenserPumpRatedPowerConsumption();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserPumpRatedPowerConsumption, *d);
     } else {
@@ -230,13 +230,13 @@ namespace energyplus {
     }
 
     //  N12, \field Low Speed Evaporative Condenser Effectiveness
-    d = modelObject.getLowSpeedEvaporativeCondenserEffectiveness();
+    d = modelObject.lowSpeedEvaporativeCondenserEffectiveness();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserEffectiveness, *d);
     }
 
     //  N13, \field Low Speed Evaporative Condenser Air Flow Rate
-    d = modelObject.getLowSpeedEvaporativeCondenserAirFlowRate();
+    d = modelObject.lowSpeedEvaporativeCondenserAirFlowRate();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserAirFlowRate, *d);
     } else {
@@ -244,7 +244,7 @@ namespace energyplus {
     }
 
     //  N14, \field Low Speed Evaporative Condenser Pump Rated Power Consumption
-    d = modelObject.getLowSpeedEvaporativeCondenserPumpRatedPowerConsumption();
+    d = modelObject.lowSpeedEvaporativeCondenserPumpRatedPowerConsumption();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserPumpRatedPowerConsumption, *d);
     } else {
@@ -260,19 +260,19 @@ namespace energyplus {
     //getCondensateCollectionWaterStorageTankName
 
     //  N15, \field Basin Heater Capacity
-    d = modelObject.getBasinHeaterCapacity();
+    d = modelObject.basinHeaterCapacity();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::BasinHeaterCapacity, *d);
     }
 
     //  N16, \field Basin Heater Setpoint Temperature
-    d = modelObject.getBasinHeaterSetpointTemperature();
+    d = modelObject.basinHeaterSetpointTemperature();
     if (d) {
       idfObject.setDouble(Coil_Cooling_DX_TwoSpeedFields::BasinHeaterSetpointTemperature, *d);
     }
 
     //  A16; \field Basin Heater Operating Schedule Name
-    OptionalSchedule os = modelObject.getBasinHeaterOperatingSchedule();
+    OptionalSchedule os = modelObject.basinHeaterOperatingSchedule();
     if (os) {
       translateAndMapModelObject(*os);
       idfObject.setString(Coil_Cooling_DX_TwoSpeedFields::BasinHeaterOperatingScheduleName, os->name().get());
@@ -305,7 +305,7 @@ namespace energyplus {
       coilSystemCoolingDXIdf.setName(*s + " CoilSystem");
     }
 
-    Schedule sched = modelObject.getAvailabilitySchedule();
+    Schedule sched = modelObject.availabilitySchedule();
     translateAndMapModelObject(sched);
 
     coilSystemCoolingDXIdf.setString(CoilSystem_Cooling_DXFields::AvailabilityScheduleName, sched.name().get());
diff --git a/src/isomodel/ForwardTranslator.cpp b/src/isomodel/ForwardTranslator.cpp
index 3e067a47491..8d41abaeb88 100644
--- a/src/isomodel/ForwardTranslator.cpp
+++ b/src/isomodel/ForwardTranslator.cpp
@@ -1717,11 +1717,11 @@ namespace isomodel {
         double area = cooling_coil_area_array[i];
         if (coil.optionalCast<openstudio::model::CoilCoolingDXSingleSpeed>()) {
           // check for single speed DX coil;
-          cop_sum += coil.optionalCast<openstudio::model::CoilCoolingDXSingleSpeed>().get().ratedCOP().get() * area;
+          cop_sum += coil.optionalCast<openstudio::model::CoilCoolingDXSingleSpeed>().get().ratedCOP() * area;
           cop_area_sum += area;
         } else if (coil.optionalCast<openstudio::model::CoilCoolingDXTwoSpeed>()) {
           // check for two speed DX coil;
-          cop_sum += coil.optionalCast<openstudio::model::CoilCoolingDXTwoSpeed>().get().ratedHighSpeedCOP().get() * area;
+          cop_sum += coil.optionalCast<openstudio::model::CoilCoolingDXTwoSpeed>().get().ratedHighSpeedCOP() * area;
           cop_area_sum += area;
         } else if (coil.optionalCast<openstudio::model::AirLoopHVACUnitaryHeatPumpAirToAir>()) {
           // check for heat pump;
@@ -1731,7 +1731,6 @@ namespace isomodel {
                        .optionalCast<openstudio::model::CoilCoolingDXSingleSpeed>()
                        .get()
                        .ratedCOP()
-                       .get()
                      * area;
           cop_area_sum += area;
         } else if (coil.optionalCast<openstudio::model::ChillerElectricEIR>()) {
@@ -1753,11 +1752,11 @@ namespace isomodel {
             // if we are here then we don't have a specific area assigned to the cooling unit so use the full building floor area;
             if (component.optionalCast<openstudio::model::CoilCoolingDXSingleSpeed>()) {
               // check for single speed DX coil;
-              cop_sum += component.optionalCast<openstudio::model::CoilCoolingDXSingleSpeed>().get().ratedCOP().get();
+              cop_sum += component.optionalCast<openstudio::model::CoilCoolingDXSingleSpeed>().get().ratedCOP();
               cop_area_sum += building.floorArea();
             } else if (component.optionalCast<openstudio::model::CoilCoolingDXTwoSpeed>()) {
               // check for two speed DX coil;
-              cop_sum += component.optionalCast<openstudio::model::CoilCoolingDXTwoSpeed>().get().ratedHighSpeedCOP().get();
+              cop_sum += component.optionalCast<openstudio::model::CoilCoolingDXTwoSpeed>().get().ratedHighSpeedCOP();
               cop_area_sum += area;
             } else if (component.optionalCast<openstudio::model::ChillerElectricEIR>()) {
               // check for a chiller;
diff --git a/src/model/CoilCoolingDXSingleSpeed.cpp b/src/model/CoilCoolingDXSingleSpeed.cpp
index 6c94de225ef..d45eda52ce4 100644
--- a/src/model/CoilCoolingDXSingleSpeed.cpp
+++ b/src/model/CoilCoolingDXSingleSpeed.cpp
@@ -201,32 +201,32 @@ namespace model {
       return result;
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::ratedCOP() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatedCOP);
+    double CoilCoolingDXSingleSpeed_Impl::ratedCOP() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatedCOP);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setRatedCOP(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatedCOP, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setRatedCOP(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatedCOP, value);
-      ;
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::ratedEvaporatorFanPowerPerVolumeFlowRate() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatedEvaporatorFanPowerPerVolumeFlowRate);
+    double CoilCoolingDXSingleSpeed_Impl::ratedEvaporatorFanPowerPerVolumeFlowRate() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatedEvaporatorFanPowerPerVolumeFlowRate);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setRatedEvaporatorFanPowerPerVolumeFlowRate(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatedEvaporatorFanPowerPerVolumeFlowRate, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setRatedEvaporatorFanPowerPerVolumeFlowRate(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatedEvaporatorFanPowerPerVolumeFlowRate, value);
-      ;
     }
 
     Curve CoilCoolingDXSingleSpeed_Impl::totalCoolingCapacityFunctionOfTemperatureCurve() const {
@@ -279,60 +279,61 @@ namespace model {
       return setPointer(OS_Coil_Cooling_DX_SingleSpeedFields::PartLoadFractionCorrelationCurveName, curve.handle());
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::nominalTimeForCondensateRemovalToBegin() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::NominalTimeforCondensateRemovaltoBegin);
+    double CoilCoolingDXSingleSpeed_Impl::nominalTimeForCondensateRemovalToBegin() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::NominalTimeforCondensateRemovaltoBegin);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setNominalTimeForCondensateRemovalToBegin(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::NominalTimeforCondensateRemovaltoBegin, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setNominalTimeForCondensateRemovalToBegin(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::NominalTimeforCondensateRemovaltoBegin, value);
-      ;
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity);
+    double CoilCoolingDXSingleSpeed_Impl::ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const {
+      boost::optional<double> value =
+        getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::RatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity, value);
-      ;
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::maximumCyclingRate() {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::MaximumCyclingRate);
+    double CoilCoolingDXSingleSpeed_Impl::maximumCyclingRate() {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::MaximumCyclingRate);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setMaximumCyclingRate(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::MaximumCyclingRate, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setMaximumCyclingRate(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::MaximumCyclingRate, value);
-      ;
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::latentCapacityTimeConstant() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::LatentCapacityTimeConstant);
+    double CoilCoolingDXSingleSpeed_Impl::latentCapacityTimeConstant() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::LatentCapacityTimeConstant);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setLatentCapacityTimeConstant(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::LatentCapacityTimeConstant, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setLatentCapacityTimeConstant(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::LatentCapacityTimeConstant, value);
-      ;
     }
 
     OptionalString CoilCoolingDXSingleSpeed_Impl::condenserAirInletNodeName() const {
@@ -351,24 +352,33 @@ namespace model {
       return setString(OS_Coil_Cooling_DX_SingleSpeedFields::CondenserType, value);
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::evaporativeCondenserEffectiveness() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserEffectiveness);
+    double CoilCoolingDXSingleSpeed_Impl::evaporativeCondenserEffectiveness() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserEffectiveness);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setEvaporativeCondenserEffectiveness(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserEffectiveness, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setEvaporativeCondenserEffectiveness(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserEffectiveness, value);
-      ;
     }
 
     OptionalDouble CoilCoolingDXSingleSpeed_Impl::evaporativeCondenserAirFlowRate() const {
       return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserAirFlowRate);
     }
 
+    bool CoilCoolingDXSingleSpeed_Impl::isEvaporativeCondenserAirFlowRateAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserAirFlowRate, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
     bool CoilCoolingDXSingleSpeed_Impl::setEvaporativeCondenserAirFlowRate(OptionalDouble value) {
       if (value) {
         return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserAirFlowRate, *value);
@@ -379,13 +389,26 @@ namespace model {
 
     bool CoilCoolingDXSingleSpeed_Impl::setEvaporativeCondenserAirFlowRate(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserAirFlowRate, value);
-      ;
+    }
+
+    void CoilCoolingDXSingleSpeed_Impl::autosizeEvaporativeCondenserAirFlowRate() {
+      bool result = setString(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserAirFlowRate, "autosize");
+      OS_ASSERT(result);
     }
 
     OptionalDouble CoilCoolingDXSingleSpeed_Impl::evaporativeCondenserPumpRatedPowerConsumption() const {
       return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserPumpRatedPowerConsumption);
     }
 
+    bool CoilCoolingDXSingleSpeed_Impl::isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() const {
+      bool result = false;
+      boost::optional<std::string> value = getString(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserPumpRatedPowerConsumption, true);
+      if (value) {
+        result = openstudio::istringEqual(value.get(), "autosize");
+      }
+      return result;
+    }
+
     bool CoilCoolingDXSingleSpeed_Impl::setEvaporativeCondenserPumpRatedPowerConsumption(OptionalDouble value) {
       if (value) {
         return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserPumpRatedPowerConsumption, *value);
@@ -396,35 +419,39 @@ namespace model {
 
     bool CoilCoolingDXSingleSpeed_Impl::setEvaporativeCondenserPumpRatedPowerConsumption(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserPumpRatedPowerConsumption, value);
-      ;
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::crankcaseHeaterCapacity() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::CrankcaseHeaterCapacity);
+    void CoilCoolingDXSingleSpeed_Impl::autosizeEvaporativeCondenserPumpRatedPowerConsumption() {
+      bool result = setString(OS_Coil_Cooling_DX_SingleSpeedFields::EvaporativeCondenserPumpRatedPowerConsumption, "autosize");
+      OS_ASSERT(result);
+    }
+
+    double CoilCoolingDXSingleSpeed_Impl::crankcaseHeaterCapacity() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::CrankcaseHeaterCapacity);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setCrankcaseHeaterCapacity(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::CrankcaseHeaterCapacity, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setCrankcaseHeaterCapacity(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::CrankcaseHeaterCapacity, value);
-      ;
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::MaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation);
+    double CoilCoolingDXSingleSpeed_Impl::maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::MaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::MaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::MaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation, value);
-      ;
     }
 
     //getSupplyWaterStorageTankName
@@ -433,32 +460,32 @@ namespace model {
     //getCondensateCollectionWaterStorageTankName
     //setCondensateCollectionWaterStorageTankName
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::basinHeaterCapacity() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterCapacity);
+    double CoilCoolingDXSingleSpeed_Impl::basinHeaterCapacity() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterCapacity);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setBasinHeaterCapacity(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterCapacity, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setBasinHeaterCapacity(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterCapacity, value);
-      ;
     }
 
-    OptionalDouble CoilCoolingDXSingleSpeed_Impl::basinHeaterSetpointTemperature() const {
-      return getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterSetpointTemperature);
+    double CoilCoolingDXSingleSpeed_Impl::basinHeaterSetpointTemperature() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterSetpointTemperature);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setBasinHeaterSetpointTemperature(boost::optional<double> value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterSetpointTemperature, value.get());
-      ;
     }
 
     bool CoilCoolingDXSingleSpeed_Impl::setBasinHeaterSetpointTemperature(double value) {
       return setDouble(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterSetpointTemperature, value);
-      ;
     }
 
     boost::optional<Schedule> CoilCoolingDXSingleSpeed_Impl::basinHeaterOperatingSchedule() const {
@@ -766,9 +793,8 @@ namespace model {
       autosizeRatedTotalCoolingCapacity();
       autosizeRatedSensibleHeatRatio();
       autosizeRatedAirFlowRate();
-      boost::optional<double> emptyVal;
-      setEvaporativeCondenserAirFlowRate(emptyVal);
-      setEvaporativeCondenserPumpRatedPowerConsumption(emptyVal);
+      autosizeEvaporativeCondenserAirFlowRate();
+      autosizeEvaporativeCondenserPumpRatedPowerConsumption();
     }
 
     void CoilCoolingDXSingleSpeed_Impl::applySizingValues() {
@@ -897,18 +923,21 @@ namespace model {
     setEnergyInputRatioFunctionOfFlowFractionCurve(energyInputRatioFofFlow);
     setPartLoadFractionCorrelationCurve(partLoadFraction);
     setEvaporativeCondenserEffectiveness(0.0);
-    setEvaporativeCondenserAirFlowRate(boost::none);
-    setEvaporativeCondenserPumpRatedPowerConsumption(boost::none);
+    autosizeEvaporativeCondenserAirFlowRate();                //autosize
+    autosizeEvaporativeCondenserPumpRatedPowerConsumption();  //autosize
     setCrankcaseHeaterCapacity(0.0);
     setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(0.0);
     setMinimumOutdoorDryBulbTemperatureforCompressorOperation(-25.0);  // Per E+ IDD default
-    //setSupplyWaterStorageTankName("");
-    //setCondensateCollectionWaterStorageTankName("");
+    setNominalTimeForCondensateRemovalToBegin(0.0);
+    setRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(0.0);
+    setMaximumCyclingRate(0.0);
+    setLatentCapacityTimeConstant(0.0);
+    setCondenserType("AirCooled");
+    setEvaporativeCondenserEffectiveness(0.9);
+    setCrankcaseHeaterCapacity(0.0);
+    setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(10.0);
     setBasinHeaterCapacity(0.0);
     setBasinHeaterSetpointTemperature(10.0);
-    //setBasinHeaterOperatingSchedule(boost::none);
-    setString(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterOperatingScheduleName, "");
-    setCondenserType("AirCooled");
 
     auto schedule = model.alwaysOnDiscreteSchedule();
     setAvailabilitySchedule(schedule);
@@ -936,18 +965,21 @@ namespace model {
     setEnergyInputRatioFunctionOfFlowFractionCurve(energyInputRatioFofFlow);
     setPartLoadFractionCorrelationCurve(partLoadFraction);
     setEvaporativeCondenserEffectiveness(0.0);
-    setEvaporativeCondenserAirFlowRate(boost::none);
-    setEvaporativeCondenserPumpRatedPowerConsumption(boost::none);
+    autosizeEvaporativeCondenserAirFlowRate();                //autosize
+    autosizeEvaporativeCondenserPumpRatedPowerConsumption();  //autosize
     setCrankcaseHeaterCapacity(0.0);
     setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(0.0);
     setMinimumOutdoorDryBulbTemperatureforCompressorOperation(-25.0);  // Per E+ IDD default
-    //setSupplyWaterStorageTankName("");
-    //setCondensateCollectionWaterStorageTankName("");
+    setNominalTimeForCondensateRemovalToBegin(0.0);
+    setRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(0.0);
+    setMaximumCyclingRate(0.0);
+    setLatentCapacityTimeConstant(0.0);
+    setCondenserType("AirCooled");
+    setEvaporativeCondenserEffectiveness(0.9);
+    setCrankcaseHeaterCapacity(0.0);
+    setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(10.0);
     setBasinHeaterCapacity(0.0);
     setBasinHeaterSetpointTemperature(10.0);
-    //setBasinHeaterOperatingSchedule(boost::none);
-    setString(OS_Coil_Cooling_DX_SingleSpeedFields::BasinHeaterOperatingScheduleName, "");
-    setCondenserType("AirCooled");
   }
 
   CoilCoolingDXSingleSpeed::CoilCoolingDXSingleSpeed(std::shared_ptr<detail::CoilCoolingDXSingleSpeed_Impl> p) : StraightComponent(std::move(p)) {}
@@ -956,40 +988,30 @@ namespace model {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->availabilitySchedule();
   }
 
-  // deprecated
-  Schedule CoilCoolingDXSingleSpeed::getAvailabilitySchedule() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->availabilitySchedule();
-  }
-
   bool CoilCoolingDXSingleSpeed::setAvailabilitySchedule(Schedule& schedule) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setAvailabilitySchedule(schedule);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::ratedCOP() const {
+  double CoilCoolingDXSingleSpeed::ratedCOP() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->ratedCOP();
   }
 
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getRatedCOP() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->ratedCOP();
-  }
   bool CoilCoolingDXSingleSpeed::setRatedCOP(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setRatedCOP(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setRatedCOP(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setRatedCOP(value);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::ratedEvaporatorFanPowerPerVolumeFlowRate() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->ratedEvaporatorFanPowerPerVolumeFlowRate();
-  }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getRatedEvaporatorFanPowerPerVolumeFlowRate() const {
+  double CoilCoolingDXSingleSpeed::ratedEvaporatorFanPowerPerVolumeFlowRate() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->ratedEvaporatorFanPowerPerVolumeFlowRate();
   }
+
   bool CoilCoolingDXSingleSpeed::setRatedEvaporatorFanPowerPerVolumeFlowRate(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setRatedEvaporatorFanPowerPerVolumeFlowRate(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setRatedEvaporatorFanPowerPerVolumeFlowRate(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setRatedEvaporatorFanPowerPerVolumeFlowRate(value);
   }
@@ -997,10 +1019,7 @@ namespace model {
   Curve CoilCoolingDXSingleSpeed::totalCoolingCapacityFunctionOfTemperatureCurve() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->totalCoolingCapacityFunctionOfTemperatureCurve();
   }
-  // deprecated
-  Curve CoilCoolingDXSingleSpeed::getTotalCoolingCapacityFunctionOfTemperatureCurve() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->totalCoolingCapacityFunctionOfTemperatureCurve();
-  }
+
   bool CoilCoolingDXSingleSpeed::setTotalCoolingCapacityFunctionOfTemperatureCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setTotalCoolingCapacityFunctionOfTemperatureCurve(curve);
   }
@@ -1008,10 +1027,7 @@ namespace model {
   Curve CoilCoolingDXSingleSpeed::totalCoolingCapacityFunctionOfFlowFractionCurve() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->totalCoolingCapacityFunctionOfFlowFractionCurve();
   }
-  // deprecated
-  Curve CoilCoolingDXSingleSpeed::getTotalCoolingCapacityFunctionOfFlowFractionCurve() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->totalCoolingCapacityFunctionOfFlowFractionCurve();
-  }
+
   bool CoilCoolingDXSingleSpeed::setTotalCoolingCapacityFunctionOfFlowFractionCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setTotalCoolingCapacityFunctionOfFlowFractionCurve(curve);
   }
@@ -1019,10 +1035,7 @@ namespace model {
   Curve CoilCoolingDXSingleSpeed::energyInputRatioFunctionOfTemperatureCurve() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->energyInputRatioFunctionOfTemperatureCurve();
   }
-  // deprecated
-  Curve CoilCoolingDXSingleSpeed::getEnergyInputRatioFunctionOfTemperatureCurve() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->energyInputRatioFunctionOfTemperatureCurve();
-  }
+
   bool CoilCoolingDXSingleSpeed::setEnergyInputRatioFunctionOfTemperatureCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setEnergyInputRatioFunctionOfTemperatureCurve(curve);
   }
@@ -1030,10 +1043,7 @@ namespace model {
   Curve CoilCoolingDXSingleSpeed::energyInputRatioFunctionOfFlowFractionCurve() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->energyInputRatioFunctionOfFlowFractionCurve();
   }
-  // deprecated
-  Curve CoilCoolingDXSingleSpeed::getEnergyInputRatioFunctionOfFlowFractionCurve() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->energyInputRatioFunctionOfFlowFractionCurve();
-  }
+
   bool CoilCoolingDXSingleSpeed::setEnergyInputRatioFunctionOfFlowFractionCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setEnergyInputRatioFunctionOfFlowFractionCurve(curve);
   }
@@ -1041,35 +1051,27 @@ namespace model {
   Curve CoilCoolingDXSingleSpeed::partLoadFractionCorrelationCurve() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->partLoadFractionCorrelationCurve();
   }
-  // deprecated
-  Curve CoilCoolingDXSingleSpeed::getPartLoadFractionCorrelationCurve() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->partLoadFractionCorrelationCurve();
-  }
+
   bool CoilCoolingDXSingleSpeed::setPartLoadFractionCorrelationCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setPartLoadFractionCorrelationCurve(curve);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::nominalTimeForCondensateRemovalToBegin() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->nominalTimeForCondensateRemovalToBegin();
-  }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getNominalTimeForCondensateRemovalToBegin() const {
+  double CoilCoolingDXSingleSpeed::nominalTimeForCondensateRemovalToBegin() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->nominalTimeForCondensateRemovalToBegin();
   }
+
   bool CoilCoolingDXSingleSpeed::setNominalTimeForCondensateRemovalToBegin(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setNominalTimeForCondensateRemovalToBegin(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setNominalTimeForCondensateRemovalToBegin(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setNominalTimeForCondensateRemovalToBegin(value);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity();
-  }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const {
+  double CoilCoolingDXSingleSpeed::ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity();
   }
+
   bool CoilCoolingDXSingleSpeed::setRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(value);
   }
@@ -1077,30 +1079,26 @@ namespace model {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(value);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::maximumCyclingRate() {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->maximumCyclingRate();
-  }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getMaximumCyclingRate() {
+  double CoilCoolingDXSingleSpeed::maximumCyclingRate() {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->maximumCyclingRate();
   }
+
   bool CoilCoolingDXSingleSpeed::setMaximumCyclingRate(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setMaximumCyclingRate(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setMaximumCyclingRate(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setMaximumCyclingRate(value);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::latentCapacityTimeConstant() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->latentCapacityTimeConstant();
-  }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getLatentCapacityTimeConstant() const {
+  double CoilCoolingDXSingleSpeed::latentCapacityTimeConstant() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->latentCapacityTimeConstant();
   }
+
   bool CoilCoolingDXSingleSpeed::setLatentCapacityTimeConstant(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setLatentCapacityTimeConstant(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setLatentCapacityTimeConstant(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setLatentCapacityTimeConstant(value);
   }
@@ -1108,10 +1106,7 @@ namespace model {
   boost::optional<std::string> CoilCoolingDXSingleSpeed::condenserAirInletNodeName() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->condenserAirInletNodeName();
   }
-  // deprecated
-  boost::optional<std::string> CoilCoolingDXSingleSpeed::getCondenserAirInletNodeName() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->condenserAirInletNodeName();
-  }
+
   bool CoilCoolingDXSingleSpeed::setCondenserAirInletNodeName(const boost::optional<std::string>& value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setCondenserAirInletNodeName(value);
   }
@@ -1119,24 +1114,19 @@ namespace model {
   std::string CoilCoolingDXSingleSpeed::condenserType() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->condenserType();
   }
-  // deprecated
-  std::string CoilCoolingDXSingleSpeed::getCondenserType() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->condenserType();
-  }
+
   bool CoilCoolingDXSingleSpeed::setCondenserType(const std::string& value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setCondenserType(value);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::evaporativeCondenserEffectiveness() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->evaporativeCondenserEffectiveness();
-  }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getEvaporativeCondenserEffectiveness() const {
+  double CoilCoolingDXSingleSpeed::evaporativeCondenserEffectiveness() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->evaporativeCondenserEffectiveness();
   }
+
   bool CoilCoolingDXSingleSpeed::setEvaporativeCondenserEffectiveness(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setEvaporativeCondenserEffectiveness(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setEvaporativeCondenserEffectiveness(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setEvaporativeCondenserEffectiveness(value);
   }
@@ -1144,55 +1134,63 @@ namespace model {
   OptionalDouble CoilCoolingDXSingleSpeed::evaporativeCondenserAirFlowRate() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->evaporativeCondenserAirFlowRate();
   }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getEvaporativeCondenserAirFlowRate() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->evaporativeCondenserAirFlowRate();
+
+  bool CoilCoolingDXSingleSpeed::isEvaporativeCondenserAirFlowRateAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->isEvaporativeCondenserAirFlowRateAutosized();
   }
+
   bool CoilCoolingDXSingleSpeed::setEvaporativeCondenserAirFlowRate(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setEvaporativeCondenserAirFlowRate(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setEvaporativeCondenserAirFlowRate(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setEvaporativeCondenserAirFlowRate(value);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::evaporativeCondenserPumpRatedPowerConsumption() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->evaporativeCondenserPumpRatedPowerConsumption();
+  void CoilCoolingDXSingleSpeed::autosizeEvaporativeCondenserAirFlowRate() {
+    getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->autosizeEvaporativeCondenserAirFlowRate();
+  }
+
+  bool CoilCoolingDXSingleSpeed::isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() const {
+    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->isEvaporativeCondenserPumpRatedPowerConsumptionAutosized();
   }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getEvaporativeCondenserPumpRatedPowerConsumption() const {
+
+  OptionalDouble CoilCoolingDXSingleSpeed::evaporativeCondenserPumpRatedPowerConsumption() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->evaporativeCondenserPumpRatedPowerConsumption();
   }
+
   bool CoilCoolingDXSingleSpeed::setEvaporativeCondenserPumpRatedPowerConsumption(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setEvaporativeCondenserPumpRatedPowerConsumption(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setEvaporativeCondenserPumpRatedPowerConsumption(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setEvaporativeCondenserPumpRatedPowerConsumption(value);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::crankcaseHeaterCapacity() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->crankcaseHeaterCapacity();
+  void CoilCoolingDXSingleSpeed::autosizeEvaporativeCondenserPumpRatedPowerConsumption() {
+    getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->autosizeEvaporativeCondenserPumpRatedPowerConsumption();
   }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getCrankcaseHeaterCapacity() const {
+
+  double CoilCoolingDXSingleSpeed::crankcaseHeaterCapacity() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->crankcaseHeaterCapacity();
   }
+
   bool CoilCoolingDXSingleSpeed::setCrankcaseHeaterCapacity(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setCrankcaseHeaterCapacity(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setCrankcaseHeaterCapacity(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setCrankcaseHeaterCapacity(value);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation();
-  }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const {
+  double CoilCoolingDXSingleSpeed::maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation();
   }
+
   bool CoilCoolingDXSingleSpeed::setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(value);
   }
@@ -1203,30 +1201,26 @@ namespace model {
   //getCondensateCollectionWaterStorageTankName
   //setCondensateCollectionWaterStorageTankName
 
-  OptionalDouble CoilCoolingDXSingleSpeed::basinHeaterCapacity() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->basinHeaterCapacity();
-  }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getBasinHeaterCapacity() const {
+  double CoilCoolingDXSingleSpeed::basinHeaterCapacity() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->basinHeaterCapacity();
   }
+
   bool CoilCoolingDXSingleSpeed::setBasinHeaterCapacity(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setBasinHeaterCapacity(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setBasinHeaterCapacity(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setBasinHeaterCapacity(value);
   }
 
-  OptionalDouble CoilCoolingDXSingleSpeed::basinHeaterSetpointTemperature() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->basinHeaterSetpointTemperature();
-  }
-  // deprecated
-  OptionalDouble CoilCoolingDXSingleSpeed::getBasinHeaterSetpointTemperature() const {
+  double CoilCoolingDXSingleSpeed::basinHeaterSetpointTemperature() const {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->basinHeaterSetpointTemperature();
   }
+
   bool CoilCoolingDXSingleSpeed::setBasinHeaterSetpointTemperature(boost::optional<double> value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setBasinHeaterSetpointTemperature(value);
   }
+
   bool CoilCoolingDXSingleSpeed::setBasinHeaterSetpointTemperature(double value) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setBasinHeaterSetpointTemperature(value);
   }
@@ -1235,11 +1229,6 @@ namespace model {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->basinHeaterOperatingSchedule();
   }
 
-  // deprecated
-  OptionalSchedule CoilCoolingDXSingleSpeed::getBasinHeaterOperatingSchedule() const {
-    return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->basinHeaterOperatingSchedule();
-  }
-
   bool CoilCoolingDXSingleSpeed::setBasinHeaterOperatingSchedule(Schedule& schedule) {
     return getImpl<detail::CoilCoolingDXSingleSpeed_Impl>()->setBasinHeaterOperatingSchedule(schedule);
   }
diff --git a/src/model/CoilCoolingDXSingleSpeed.hpp b/src/model/CoilCoolingDXSingleSpeed.hpp
index af824d2a1e2..3a277b0e3d9 100644
--- a/src/model/CoilCoolingDXSingleSpeed.hpp
+++ b/src/model/CoilCoolingDXSingleSpeed.hpp
@@ -90,10 +90,10 @@ namespace model {
     Schedule availabilitySchedule() const;
 
     /** Returns the value of the RatedCOP field. **/
-    boost::optional<double> ratedCOP() const;
+    double ratedCOP() const;
 
     /** Returns the value of the RatedEvaporatorFanPowerPerVolumeFlowRate field. **/
-    boost::optional<double> ratedEvaporatorFanPowerPerVolumeFlowRate() const;
+    double ratedEvaporatorFanPowerPerVolumeFlowRate() const;
 
     /** Returns the CurveBiquadratic referred to by the TotalCoolingCapacityFunctionOfTemperatureCurveName field. **/
     Curve totalCoolingCapacityFunctionOfTemperatureCurve() const;
@@ -111,16 +111,16 @@ namespace model {
     Curve partLoadFractionCorrelationCurve() const;
 
     /** Returns the value of the NominalTimeForCondensateRemovalToBegin field. **/
-    boost::optional<double> nominalTimeForCondensateRemovalToBegin() const;
+    double nominalTimeForCondensateRemovalToBegin() const;
 
     /** Returns the value of the RatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity field. **/
-    boost::optional<double> ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const;
+    double ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const;
 
     /** Returns the value of the MaximumCyclingRate field. **/
-    boost::optional<double> maximumCyclingRate();
+    double maximumCyclingRate();
 
     /** Returns the value of the latentCapacityTimeConstant field. **/
-    boost::optional<double> latentCapacityTimeConstant() const;
+    double latentCapacityTimeConstant() const;
 
     boost::optional<std::string> condenserAirInletNodeName() const;
 
@@ -128,7 +128,7 @@ namespace model {
     std::string condenserType() const;
 
     /** Returns the value of the EvaporativeCondenserEffectiveness field. **/
-    boost::optional<double> evaporativeCondenserEffectiveness() const;
+    double evaporativeCondenserEffectiveness() const;
 
     /** Returns the value of the EvaporativeCondenserAirFlowRate field.
       optional == false means "autosize"
@@ -141,86 +141,20 @@ namespace model {
     boost::optional<double> evaporativeCondenserPumpRatedPowerConsumption() const;
 
     /** Returns the value of the crankcaseHeaterCapacity field. **/
-    boost::optional<double> crankcaseHeaterCapacity() const;
+    double crankcaseHeaterCapacity() const;
 
     /** Returns the value of the MaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation field. **/
-    boost::optional<double> maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const;
+    double maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const;
 
     /** Returns the value of the BasinHeaterCapacity field. **/
-    boost::optional<double> basinHeaterCapacity() const;
+    double basinHeaterCapacity() const;
 
     /** Returns the value of the BasinHeaterSetpointTemperature field. **/
-    boost::optional<double> basinHeaterSetpointTemperature() const;
+    double basinHeaterSetpointTemperature() const;
 
     /** Returns the Schedule referred to by the BasinHeaterOperatingSchedule field. **/
     boost::optional<Schedule> basinHeaterOperatingSchedule() const;
 
-    /** \deprecated */
-    Schedule getAvailabilitySchedule() const;
-
-    /** \deprecated */
-    boost::optional<double> getRatedCOP() const;
-
-    /** \deprecated */
-    boost::optional<double> getRatedEvaporatorFanPowerPerVolumeFlowRate() const;
-
-    /** \deprecated */
-    Curve getTotalCoolingCapacityFunctionOfTemperatureCurve() const;
-
-    /** \deprecated */
-    Curve getTotalCoolingCapacityFunctionOfFlowFractionCurve() const;
-
-    /** \deprecated */
-    Curve getEnergyInputRatioFunctionOfTemperatureCurve() const;
-
-    /** \deprecated */
-    Curve getEnergyInputRatioFunctionOfFlowFractionCurve() const;
-
-    /** \deprecated */
-    Curve getPartLoadFractionCorrelationCurve() const;
-
-    /** \deprecated */
-    boost::optional<double> getNominalTimeForCondensateRemovalToBegin() const;
-
-    /** \deprecated */
-    boost::optional<double> getRatioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const;
-
-    /** \deprecated */
-    boost::optional<double> getMaximumCyclingRate();
-
-    /** \deprecated */
-    boost::optional<double> getLatentCapacityTimeConstant() const;
-
-    /** \deprecated */
-    boost::optional<std::string> getCondenserAirInletNodeName() const;
-
-    /** \deprecated */
-    std::string getCondenserType() const;
-
-    /** \deprecated */
-    boost::optional<double> getEvaporativeCondenserEffectiveness() const;
-
-    /** \deprecated */
-    boost::optional<double> getEvaporativeCondenserAirFlowRate() const;
-
-    /** \deprecated */
-    boost::optional<double> getEvaporativeCondenserPumpRatedPowerConsumption() const;
-
-    /** \deprecated */
-    boost::optional<double> getCrankcaseHeaterCapacity() const;
-
-    /** \deprecated */
-    boost::optional<double> getMaximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const;
-
-    /** \deprecated */
-    boost::optional<double> getBasinHeaterCapacity() const;
-
-    /** \deprecated */
-    boost::optional<double> getBasinHeaterSetpointTemperature() const;
-
-    /** \deprecated */
-    boost::optional<Schedule> getBasinHeaterOperatingSchedule() const;
-
     double minimumOutdoorDryBulbTemperatureforCompressorOperation() const;
 
     //@}
@@ -287,6 +221,8 @@ namespace model {
 
     bool setEvaporativeCondenserEffectiveness(double value);
 
+    bool isEvaporativeCondenserAirFlowRateAutosized() const;
+
     /** Sets the value of the EvaporativeCondenserAirFlowRate field.
       if value==false then set field to "autosize"
   **/
@@ -294,6 +230,10 @@ namespace model {
 
     bool setEvaporativeCondenserAirFlowRate(double value);
 
+    void autosizeEvaporativeCondenserAirFlowRate();
+
+    bool isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() const;
+
     /** Sets the value of the EvaporativeCondenserPumpRatedPowerConsumption field.
       if value==false then set field to "autosize"
   **/
@@ -301,6 +241,8 @@ namespace model {
 
     bool setEvaporativeCondenserPumpRatedPowerConsumption(double value);
 
+    void autosizeEvaporativeCondenserPumpRatedPowerConsumption();
+
     /** Sets the value of the crankcaseHeaterCapacity field. **/
     bool setCrankcaseHeaterCapacity(boost::optional<double> value);
 
diff --git a/src/model/CoilCoolingDXSingleSpeed_Impl.hpp b/src/model/CoilCoolingDXSingleSpeed_Impl.hpp
index 09b1f54ffe5..0ceaaed7f27 100644
--- a/src/model/CoilCoolingDXSingleSpeed_Impl.hpp
+++ b/src/model/CoilCoolingDXSingleSpeed_Impl.hpp
@@ -90,9 +90,9 @@ namespace model {
 
       Schedule availabilitySchedule() const;
 
-      boost::optional<double> ratedCOP() const;
+      double ratedCOP() const;
 
-      boost::optional<double> ratedEvaporatorFanPowerPerVolumeFlowRate() const;
+      double ratedEvaporatorFanPowerPerVolumeFlowRate() const;
 
       Curve totalCoolingCapacityFunctionOfTemperatureCurve() const;
 
@@ -104,31 +104,31 @@ namespace model {
 
       Curve partLoadFractionCorrelationCurve() const;
 
-      boost::optional<double> nominalTimeForCondensateRemovalToBegin() const;
+      double nominalTimeForCondensateRemovalToBegin() const;
 
-      boost::optional<double> ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const;
+      double ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity() const;
 
-      boost::optional<double> maximumCyclingRate();
+      double maximumCyclingRate();
 
-      boost::optional<double> latentCapacityTimeConstant() const;
+      double latentCapacityTimeConstant() const;
 
       boost::optional<std::string> condenserAirInletNodeName() const;
 
       std::string condenserType() const;
 
-      boost::optional<double> evaporativeCondenserEffectiveness() const;
+      double evaporativeCondenserEffectiveness() const;
 
       boost::optional<double> evaporativeCondenserAirFlowRate() const;
 
       boost::optional<double> evaporativeCondenserPumpRatedPowerConsumption() const;
 
-      boost::optional<double> crankcaseHeaterCapacity() const;
+      double crankcaseHeaterCapacity() const;
 
-      boost::optional<double> maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const;
+      double maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation() const;
 
-      boost::optional<double> basinHeaterCapacity() const;
+      double basinHeaterCapacity() const;
 
-      boost::optional<double> basinHeaterSetpointTemperature() const;
+      double basinHeaterSetpointTemperature() const;
 
       boost::optional<Schedule> basinHeaterOperatingSchedule() const;
 
@@ -198,14 +198,22 @@ namespace model {
 
       bool setEvaporativeCondenserEffectiveness(double value);
 
+      bool isEvaporativeCondenserAirFlowRateAutosized() const;
+
       bool setEvaporativeCondenserAirFlowRate(boost::optional<double> value);
 
       bool setEvaporativeCondenserAirFlowRate(double value);
 
+      void autosizeEvaporativeCondenserAirFlowRate();
+
+      bool isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() const;
+
       bool setEvaporativeCondenserPumpRatedPowerConsumption(boost::optional<double> value);
 
       bool setEvaporativeCondenserPumpRatedPowerConsumption(double value);
 
+      void autosizeEvaporativeCondenserPumpRatedPowerConsumption();
+
       bool setCrankcaseHeaterCapacity(boost::optional<double> value);
 
       bool setCrankcaseHeaterCapacity(double value);
diff --git a/src/model/CoilCoolingDXTwoSpeed.cpp b/src/model/CoilCoolingDXTwoSpeed.cpp
index a88c0d1943e..96f77176c8f 100644
--- a/src/model/CoilCoolingDXTwoSpeed.cpp
+++ b/src/model/CoilCoolingDXTwoSpeed.cpp
@@ -219,8 +219,10 @@ namespace model {
     }
 
     // N3 , \field Rated High Speed COP
-    OptionalDouble CoilCoolingDXTwoSpeed_Impl::ratedHighSpeedCOP() const {
-      return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedCOP);
+    double CoilCoolingDXTwoSpeed_Impl::ratedHighSpeedCOP() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedCOP);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     bool CoilCoolingDXTwoSpeed_Impl::setRatedHighSpeedCOP(double value) {
@@ -231,6 +233,7 @@ namespace model {
     OptionalDouble CoilCoolingDXTwoSpeed_Impl::ratedHighSpeedAirFlowRate() const {
       return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedAirFlowRate);
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setRatedHighSpeedAirFlowRate(OptionalDouble value) {
       if (value) {
         return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedAirFlowRate, *value);
@@ -238,6 +241,7 @@ namespace model {
         return setString(OS_Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedAirFlowRate, "Autosize");
       }
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setRatedHighSpeedAirFlowRate(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedHighSpeedAirFlowRate, value);
     }
@@ -249,6 +253,7 @@ namespace model {
       OS_ASSERT(result);
       return result.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setTotalCoolingCapacityFunctionOfTemperatureCurve(const Curve& curve) {
       return setPointer(OS_Coil_Cooling_DX_TwoSpeedFields::TotalCoolingCapacityFunctionofTemperatureCurveName, curve.handle());
     }
@@ -271,6 +276,7 @@ namespace model {
       OS_ASSERT(result);
       return result.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setEnergyInputRatioFunctionOfTemperatureCurve(const Curve& curve) {
       return setPointer(OS_Coil_Cooling_DX_TwoSpeedFields::EnergyInputRatioFunctionofTemperatureCurveName, curve.handle());
     }
@@ -282,6 +288,7 @@ namespace model {
       OS_ASSERT(result);
       return result.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setEnergyInputRatioFunctionOfFlowFractionCurve(const Curve& curve) {
       return setPointer(OS_Coil_Cooling_DX_TwoSpeedFields::EnergyInputRatioFunctionofFlowFractionCurveName, curve.handle());
     }
@@ -293,6 +300,7 @@ namespace model {
       OS_ASSERT(result);
       return result.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setPartLoadFractionCorrelationCurve(const Curve& curve) {
       return setPointer(OS_Coil_Cooling_DX_TwoSpeedFields::PartLoadFractionCorrelationCurveName, curve.handle());
     }
@@ -301,6 +309,7 @@ namespace model {
     OptionalDouble CoilCoolingDXTwoSpeed_Impl::ratedLowSpeedTotalCoolingCapacity() const {
       return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedTotalCoolingCapacity);
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setRatedLowSpeedTotalCoolingCapacity(OptionalDouble value) {
       if (value) {
         return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedTotalCoolingCapacity, *value);
@@ -308,6 +317,7 @@ namespace model {
         return setString(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedTotalCoolingCapacity, "Autosize");
       }
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setRatedLowSpeedTotalCoolingCapacity(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedTotalCoolingCapacity, value);
     }
@@ -316,6 +326,7 @@ namespace model {
     OptionalDouble CoilCoolingDXTwoSpeed_Impl::ratedLowSpeedSensibleHeatRatio() const {
       return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedSensibleHeatRatio);
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setRatedLowSpeedSensibleHeatRatio(OptionalDouble value) {
       if (value) {
         return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedSensibleHeatRatio, *value);
@@ -323,14 +334,18 @@ namespace model {
         return setString(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedSensibleHeatRatio, "Autosize");
       }
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setRatedLowSpeedSensibleHeatRatio(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedSensibleHeatRatio, value);
     }
 
     // N7 , \field Rated Low Speed COP
-    OptionalDouble CoilCoolingDXTwoSpeed_Impl::ratedLowSpeedCOP() const {
-      return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedCOP);
+    double CoilCoolingDXTwoSpeed_Impl::ratedLowSpeedCOP() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedCOP);
+      OS_ASSERT(value);
+      return value.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setRatedLowSpeedCOP(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedCOP, value);
     }
@@ -339,6 +354,7 @@ namespace model {
     OptionalDouble CoilCoolingDXTwoSpeed_Impl::ratedLowSpeedAirFlowRate() const {
       return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedAirFlowRate);
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setRatedLowSpeedAirFlowRate(OptionalDouble value) {
       if (value) {
         return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedAirFlowRate, *value);
@@ -346,6 +362,7 @@ namespace model {
         return setString(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedAirFlowRate, "Autosize");
       }
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setRatedLowSpeedAirFlowRate(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::RatedLowSpeedAirFlowRate, value);
     }
@@ -357,6 +374,7 @@ namespace model {
       OS_ASSERT(result);
       return result.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve(const Curve& curve) {
       return setPointer(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedTotalCoolingCapacityFunctionofTemperatureCurveName, curve.handle());
     }
@@ -368,6 +386,7 @@ namespace model {
       OS_ASSERT(result);
       return result.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setLowSpeedEnergyInputRatioFunctionOfTemperatureCurve(const Curve& curve) {
       return setPointer(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEnergyInputRatioFunctionofTemperatureCurveName, curve.handle());
     }
@@ -376,6 +395,7 @@ namespace model {
     OptionalString CoilCoolingDXTwoSpeed_Impl::condenserAirInletNodeName() const {
       return getString(OS_Coil_Cooling_DX_TwoSpeedFields::CondenserAirInletNodeName);
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setCondenserAirInletNodeName(const std::string& value) {
       return setString(OS_Coil_Cooling_DX_TwoSpeedFields::CondenserAirInletNodeName, value);
     }
@@ -384,14 +404,18 @@ namespace model {
     std::string CoilCoolingDXTwoSpeed_Impl::condenserType() const {
       return getString(OS_Coil_Cooling_DX_TwoSpeedFields::CondenserType).get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setCondenserType(const std::string& value) {
       return setString(OS_Coil_Cooling_DX_TwoSpeedFields::CondenserType, value);
     }
 
     // N9, \field High Speed Evaporative Condenser Effectiveness
-    OptionalDouble CoilCoolingDXTwoSpeed_Impl::highSpeedEvaporativeCondenserEffectiveness() const {
-      return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserEffectiveness);
+    double CoilCoolingDXTwoSpeed_Impl::highSpeedEvaporativeCondenserEffectiveness() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserEffectiveness);
+      OS_ASSERT(value);
+      return value.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setHighSpeedEvaporativeCondenserEffectiveness(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserEffectiveness, value);
     }
@@ -400,12 +424,14 @@ namespace model {
     OptionalDouble CoilCoolingDXTwoSpeed_Impl::highSpeedEvaporativeCondenserAirFlowRate() const {
       return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserAirFlowRate);
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setHighSpeedEvaporativeCondenserAirFlowRate(OptionalDouble value) {
       if (value)
         return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserAirFlowRate, *value);
       else
         return setString(OS_Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserAirFlowRate, "Autosize");
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setHighSpeedEvaporativeCondenserAirFlowRate(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserAirFlowRate, value);
     }
@@ -420,14 +446,18 @@ namespace model {
       else
         return setString(OS_Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserPumpRatedPowerConsumption, "Autosize");
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setHighSpeedEvaporativeCondenserPumpRatedPowerConsumption(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::HighSpeedEvaporativeCondenserPumpRatedPowerConsumption, value);
     }
 
     // N12, \field Low Speed Evaporative Condenser Effectiveness
-    OptionalDouble CoilCoolingDXTwoSpeed_Impl::lowSpeedEvaporativeCondenserEffectiveness() const {
-      return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserEffectiveness);
+    double CoilCoolingDXTwoSpeed_Impl::lowSpeedEvaporativeCondenserEffectiveness() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserEffectiveness);
+      OS_ASSERT(value);
+      return value.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setLowSpeedEvaporativeCondenserEffectiveness(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserEffectiveness, value);
     }
@@ -436,12 +466,14 @@ namespace model {
     OptionalDouble CoilCoolingDXTwoSpeed_Impl::lowSpeedEvaporativeCondenserAirFlowRate() const {
       return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserAirFlowRate);
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setLowSpeedEvaporativeCondenserAirFlowRate(OptionalDouble value) {
       if (value)
         return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserAirFlowRate, *value);
       else
         return setString(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserAirFlowRate, "Autosize");
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setLowSpeedEvaporativeCondenserAirFlowRate(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserAirFlowRate, value);
     }
@@ -450,12 +482,14 @@ namespace model {
     OptionalDouble CoilCoolingDXTwoSpeed_Impl::lowSpeedEvaporativeCondenserPumpRatedPowerConsumption() const {
       return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserPumpRatedPowerConsumption);
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setLowSpeedEvaporativeCondenserPumpRatedPowerConsumption(OptionalDouble value) {
       if (value)
         return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserPumpRatedPowerConsumption, *value);
       else
         return setString(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserPumpRatedPowerConsumption, "Autosize");
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setLowSpeedEvaporativeCondenserPumpRatedPowerConsumption(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEvaporativeCondenserPumpRatedPowerConsumption, value);
     }
@@ -471,17 +505,23 @@ namespace model {
     // setCondensateCollectionWaterStorageTankName
 
     // N15, \field Basin Heater Capacity
-    OptionalDouble CoilCoolingDXTwoSpeed_Impl::basinHeaterCapacity() const {
-      return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::BasinHeaterCapacity);
+    double CoilCoolingDXTwoSpeed_Impl::basinHeaterCapacity() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::BasinHeaterCapacity);
+      OS_ASSERT(value);
+      return value.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setBasinHeaterCapacity(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::BasinHeaterCapacity, value);
     }
 
     // N16, \field Basin Heater Setpoint Temperature
-    OptionalDouble CoilCoolingDXTwoSpeed_Impl::basinHeaterSetpointTemperature() const {
-      return getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::BasinHeaterSetpointTemperature);
+    double CoilCoolingDXTwoSpeed_Impl::basinHeaterSetpointTemperature() const {
+      boost::optional<double> value = getDouble(OS_Coil_Cooling_DX_TwoSpeedFields::BasinHeaterSetpointTemperature);
+      OS_ASSERT(value);
+      return value.get();
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setBasinHeaterSetpointTemperature(double value) {
       return setDouble(OS_Coil_Cooling_DX_TwoSpeedFields::BasinHeaterSetpointTemperature, value);
     }
@@ -490,6 +530,7 @@ namespace model {
     boost::optional<Schedule> CoilCoolingDXTwoSpeed_Impl::basinHeaterOperatingSchedule() const {
       return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_Coil_Cooling_DX_TwoSpeedFields::BasinHeaterOperatingScheduleName);
     }
+
     bool CoilCoolingDXTwoSpeed_Impl::setBasinHeaterOperatingSchedule(Schedule& schedule) {
       bool result =
         setSchedule(OS_Coil_Cooling_DX_TwoSpeedFields::BasinHeaterOperatingScheduleName, "CoilCoolingDXTwoSpeed", "Basin Heater Operation", schedule);
@@ -514,27 +555,34 @@ namespace model {
     boost::optional<Schedule> CoilCoolingDXTwoSpeed_Impl::optionalAvailabilitySchedule() const {
       return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_Coil_Cooling_DX_TwoSpeedFields::AvailabilityScheduleName);
     }
+
     boost::optional<Curve> CoilCoolingDXTwoSpeed_Impl::optionalTotalCoolingCapacityFunctionOfTemperatureCurve() const {
       return getObject<ModelObject>().getModelObjectTarget<Curve>(
         OS_Coil_Cooling_DX_TwoSpeedFields::TotalCoolingCapacityFunctionofTemperatureCurveName);
     }
+
     boost::optional<Curve> CoilCoolingDXTwoSpeed_Impl::optionalTotalCoolingCapacityFunctionOfFlowFractionCurve() const {
       return getObject<ModelObject>().getModelObjectTarget<Curve>(
         OS_Coil_Cooling_DX_TwoSpeedFields::TotalCoolingCapacityFunctionofFlowFractionCurveName);
     }
+
     boost::optional<Curve> CoilCoolingDXTwoSpeed_Impl::optionalEnergyInputRatioFunctionOfTemperatureCurve() const {
       return getObject<ModelObject>().getModelObjectTarget<Curve>(OS_Coil_Cooling_DX_TwoSpeedFields::EnergyInputRatioFunctionofTemperatureCurveName);
     }
+
     boost::optional<Curve> CoilCoolingDXTwoSpeed_Impl::optionalEnergyInputRatioFunctionOfFlowFractionCurve() const {
       return getObject<ModelObject>().getModelObjectTarget<Curve>(OS_Coil_Cooling_DX_TwoSpeedFields::EnergyInputRatioFunctionofFlowFractionCurveName);
     }
+
     boost::optional<Curve> CoilCoolingDXTwoSpeed_Impl::optionalPartLoadFractionCorrelationCurve() const {
       return getObject<ModelObject>().getModelObjectTarget<Curve>(OS_Coil_Cooling_DX_TwoSpeedFields::PartLoadFractionCorrelationCurveName);
     }
+
     boost::optional<Curve> CoilCoolingDXTwoSpeed_Impl::optionalLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve() const {
       return getObject<ModelObject>().getModelObjectTarget<Curve>(
         OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedTotalCoolingCapacityFunctionofTemperatureCurveName);
     }
+
     boost::optional<Curve> CoilCoolingDXTwoSpeed_Impl::optionalLowSpeedEnergyInputRatioFunctionOfTemperatureCurve() const {
       return getObject<ModelObject>().getModelObjectTarget<Curve>(
         OS_Coil_Cooling_DX_TwoSpeedFields::LowSpeedEnergyInputRatioFunctionofTemperatureCurveName);
@@ -950,9 +998,7 @@ namespace model {
   Schedule CoilCoolingDXTwoSpeed::availabilitySchedule() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->availabilitySchedule();
   }
-  Schedule CoilCoolingDXTwoSpeed::getAvailabilitySchedule() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->availabilitySchedule();
-  }
+
   bool CoilCoolingDXTwoSpeed::setAvailabilitySchedule(Schedule& schedule) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setAvailabilitySchedule(schedule);
   }
@@ -961,12 +1007,11 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::ratedHighSpeedTotalCoolingCapacity() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedHighSpeedTotalCoolingCapacity();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getRatedHighSpeedTotalCoolingCapacity() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedHighSpeedTotalCoolingCapacity();
-  }
+
   bool CoilCoolingDXTwoSpeed::setRatedHighSpeedTotalCoolingCapacity(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedHighSpeedTotalCoolingCapacity(value);
   }
+
   bool CoilCoolingDXTwoSpeed::setRatedHighSpeedTotalCoolingCapacity(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedHighSpeedTotalCoolingCapacity(value);
   }
@@ -975,23 +1020,20 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::ratedHighSpeedSensibleHeatRatio() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedHighSpeedSensibleHeatRatio();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getRatedHighSpeedSensibleHeatRatio() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedHighSpeedSensibleHeatRatio();
-  }
+
   bool CoilCoolingDXTwoSpeed::setRatedHighSpeedSensibleHeatRatio(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedHighSpeedSensibleHeatRatio(value);
   }
+
   bool CoilCoolingDXTwoSpeed::setRatedHighSpeedSensibleHeatRatio(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedHighSpeedSensibleHeatRatio(value);
   }
 
   //  N3 , \field Rated High Speed COP
-  OptionalDouble CoilCoolingDXTwoSpeed::ratedHighSpeedCOP() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedHighSpeedCOP();
-  }
-  OptionalDouble CoilCoolingDXTwoSpeed::getRatedHighSpeedCOP() const {
+  double CoilCoolingDXTwoSpeed::ratedHighSpeedCOP() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedHighSpeedCOP();
   }
+
   bool CoilCoolingDXTwoSpeed::setRatedHighSpeedCOP(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedHighSpeedCOP(value);
   }
@@ -1000,9 +1042,7 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::ratedHighSpeedAirFlowRate() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedHighSpeedAirFlowRate();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getRatedHighSpeedAirFlowRate() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedHighSpeedAirFlowRate();
-  }
+
   bool CoilCoolingDXTwoSpeed::setRatedHighSpeedAirFlowRate(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedHighSpeedAirFlowRate(value);
   }
@@ -1014,9 +1054,7 @@ namespace model {
   Curve CoilCoolingDXTwoSpeed::totalCoolingCapacityFunctionOfTemperatureCurve() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->totalCoolingCapacityFunctionOfTemperatureCurve();
   }
-  Curve CoilCoolingDXTwoSpeed::getTotalCoolingCapacityFunctionOfTemperatureCurve() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->totalCoolingCapacityFunctionOfTemperatureCurve();
-  }
+
   bool CoilCoolingDXTwoSpeed::setTotalCoolingCapacityFunctionOfTemperatureCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setTotalCoolingCapacityFunctionOfTemperatureCurve(curve);
   }
@@ -1025,9 +1063,7 @@ namespace model {
   Curve CoilCoolingDXTwoSpeed::totalCoolingCapacityFunctionOfFlowFractionCurve() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->totalCoolingCapacityFunctionOfFlowFractionCurve();
   }
-  Curve CoilCoolingDXTwoSpeed::getTotalCoolingCapacityFunctionOfFlowFractionCurve() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->totalCoolingCapacityFunctionOfFlowFractionCurve();
-  }
+
   bool CoilCoolingDXTwoSpeed::setTotalCoolingCapacityFunctionOfFlowFractionCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setTotalCoolingCapacityFunctionOfFlowFractionCurve(curve);
   }
@@ -1036,9 +1072,7 @@ namespace model {
   Curve CoilCoolingDXTwoSpeed::energyInputRatioFunctionOfTemperatureCurve() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->energyInputRatioFunctionOfTemperatureCurve();
   }
-  Curve CoilCoolingDXTwoSpeed::getEnergyInputRatioFunctionOfTemperatureCurve() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->energyInputRatioFunctionOfTemperatureCurve();
-  }
+
   bool CoilCoolingDXTwoSpeed::setEnergyInputRatioFunctionOfTemperatureCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setEnergyInputRatioFunctionOfTemperatureCurve(curve);
   }
@@ -1047,9 +1081,7 @@ namespace model {
   Curve CoilCoolingDXTwoSpeed::energyInputRatioFunctionOfFlowFractionCurve() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->energyInputRatioFunctionOfFlowFractionCurve();
   }
-  Curve CoilCoolingDXTwoSpeed::getEnergyInputRatioFunctionOfFlowFractionCurve() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->energyInputRatioFunctionOfFlowFractionCurve();
-  }
+
   bool CoilCoolingDXTwoSpeed::setEnergyInputRatioFunctionOfFlowFractionCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setEnergyInputRatioFunctionOfFlowFractionCurve(curve);
   }
@@ -1058,9 +1090,7 @@ namespace model {
   Curve CoilCoolingDXTwoSpeed::partLoadFractionCorrelationCurve() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->partLoadFractionCorrelationCurve();
   }
-  Curve CoilCoolingDXTwoSpeed::getPartLoadFractionCorrelationCurve() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->partLoadFractionCorrelationCurve();
-  }
+
   bool CoilCoolingDXTwoSpeed::setPartLoadFractionCorrelationCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setPartLoadFractionCorrelationCurve(curve);
   }
@@ -1069,12 +1099,11 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::ratedLowSpeedTotalCoolingCapacity() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedLowSpeedTotalCoolingCapacity();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getRatedLowSpeedTotalCoolingCapacity() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedLowSpeedTotalCoolingCapacity();
-  }
+
   bool CoilCoolingDXTwoSpeed::setRatedLowSpeedTotalCoolingCapacity(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedLowSpeedTotalCoolingCapacity(value);
   }
+
   bool CoilCoolingDXTwoSpeed::setRatedLowSpeedTotalCoolingCapacity(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedLowSpeedTotalCoolingCapacity(value);
   }
@@ -1083,23 +1112,20 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::ratedLowSpeedSensibleHeatRatio() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedLowSpeedSensibleHeatRatio();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getRatedLowSpeedSensibleHeatRatio() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedLowSpeedSensibleHeatRatio();
-  }
+
   bool CoilCoolingDXTwoSpeed::setRatedLowSpeedSensibleHeatRatio(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedLowSpeedSensibleHeatRatio(value);
   }
+
   bool CoilCoolingDXTwoSpeed::setRatedLowSpeedSensibleHeatRatio(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedLowSpeedSensibleHeatRatio(value);
   }
 
   //  N7 , \field Rated Low Speed COP
-  OptionalDouble CoilCoolingDXTwoSpeed::ratedLowSpeedCOP() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedLowSpeedCOP();
-  }
-  OptionalDouble CoilCoolingDXTwoSpeed::getRatedLowSpeedCOP() const {
+  double CoilCoolingDXTwoSpeed::ratedLowSpeedCOP() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedLowSpeedCOP();
   }
+
   bool CoilCoolingDXTwoSpeed::setRatedLowSpeedCOP(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedLowSpeedCOP(value);
   }
@@ -1108,9 +1134,7 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::ratedLowSpeedAirFlowRate() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedLowSpeedAirFlowRate();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getRatedLowSpeedAirFlowRate() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->ratedLowSpeedAirFlowRate();
-  }
+
   bool CoilCoolingDXTwoSpeed::setRatedLowSpeedAirFlowRate(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setRatedLowSpeedAirFlowRate(value);
   }
@@ -1122,9 +1146,7 @@ namespace model {
   Curve CoilCoolingDXTwoSpeed::lowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve();
   }
-  Curve CoilCoolingDXTwoSpeed::getLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve();
-  }
+
   bool CoilCoolingDXTwoSpeed::setLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve(curve);
   }
@@ -1133,9 +1155,7 @@ namespace model {
   Curve CoilCoolingDXTwoSpeed::lowSpeedEnergyInputRatioFunctionOfTemperatureCurve() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedEnergyInputRatioFunctionOfTemperatureCurve();
   }
-  Curve CoilCoolingDXTwoSpeed::getLowSpeedEnergyInputRatioFunctionOfTemperatureCurve() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedEnergyInputRatioFunctionOfTemperatureCurve();
-  }
+
   bool CoilCoolingDXTwoSpeed::setLowSpeedEnergyInputRatioFunctionOfTemperatureCurve(const Curve& curve) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setLowSpeedEnergyInputRatioFunctionOfTemperatureCurve(curve);
   }
@@ -1144,9 +1164,7 @@ namespace model {
   OptionalString CoilCoolingDXTwoSpeed::condenserAirInletNodeName() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->condenserAirInletNodeName();
   }
-  OptionalString CoilCoolingDXTwoSpeed::getCondenserAirInletNodeName() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->condenserAirInletNodeName();
-  }
+
   bool CoilCoolingDXTwoSpeed::setCondenserAirInletNodeName(const std::string& value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setCondenserAirInletNodeName(value);
   }
@@ -1155,20 +1173,16 @@ namespace model {
   std::string CoilCoolingDXTwoSpeed::condenserType() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->condenserType();
   }
-  std::string CoilCoolingDXTwoSpeed::getCondenserType() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->condenserType();
-  }
+
   bool CoilCoolingDXTwoSpeed::setCondenserType(const std::string& value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setCondenserType(value);
   }
 
   //   N9, \field High Speed Evaporative Condenser Effectiveness
-  OptionalDouble CoilCoolingDXTwoSpeed::highSpeedEvaporativeCondenserEffectiveness() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->highSpeedEvaporativeCondenserEffectiveness();
-  }
-  OptionalDouble CoilCoolingDXTwoSpeed::getHighSpeedEvaporativeCondenserEffectiveness() const {
+  double CoilCoolingDXTwoSpeed::highSpeedEvaporativeCondenserEffectiveness() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->highSpeedEvaporativeCondenserEffectiveness();
   }
+
   bool CoilCoolingDXTwoSpeed::setHighSpeedEvaporativeCondenserEffectiveness(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setHighSpeedEvaporativeCondenserEffectiveness(value);
   }
@@ -1177,12 +1191,11 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::highSpeedEvaporativeCondenserAirFlowRate() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->highSpeedEvaporativeCondenserAirFlowRate();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getHighSpeedEvaporativeCondenserAirFlowRate() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->highSpeedEvaporativeCondenserAirFlowRate();
-  }
+
   bool CoilCoolingDXTwoSpeed::setHighSpeedEvaporativeCondenserAirFlowRate(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setHighSpeedEvaporativeCondenserAirFlowRate(value);
   }
+
   bool CoilCoolingDXTwoSpeed::setHighSpeedEvaporativeCondenserAirFlowRate(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setHighSpeedEvaporativeCondenserAirFlowRate(value);
   }
@@ -1191,23 +1204,20 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::highSpeedEvaporativeCondenserPumpRatedPowerConsumption() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->highSpeedEvaporativeCondenserPumpRatedPowerConsumption();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getHighSpeedEvaporativeCondenserPumpRatedPowerConsumption() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->highSpeedEvaporativeCondenserPumpRatedPowerConsumption();
-  }
+
   bool CoilCoolingDXTwoSpeed::setHighSpeedEvaporativeCondenserPumpRatedPowerConsumption(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setHighSpeedEvaporativeCondenserPumpRatedPowerConsumption(value);
   }
+
   bool CoilCoolingDXTwoSpeed::setHighSpeedEvaporativeCondenserPumpRatedPowerConsumption(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setHighSpeedEvaporativeCondenserPumpRatedPowerConsumption(value);
   }
 
   //  N12, \field Low Speed Evaporative Condenser Effectiveness
-  OptionalDouble CoilCoolingDXTwoSpeed::lowSpeedEvaporativeCondenserEffectiveness() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedEvaporativeCondenserEffectiveness();
-  }
-  OptionalDouble CoilCoolingDXTwoSpeed::getLowSpeedEvaporativeCondenserEffectiveness() const {
+  double CoilCoolingDXTwoSpeed::lowSpeedEvaporativeCondenserEffectiveness() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedEvaporativeCondenserEffectiveness();
   }
+
   bool CoilCoolingDXTwoSpeed::setLowSpeedEvaporativeCondenserEffectiveness(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setLowSpeedEvaporativeCondenserEffectiveness(value);
   }
@@ -1216,12 +1226,11 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::lowSpeedEvaporativeCondenserAirFlowRate() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedEvaporativeCondenserAirFlowRate();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getLowSpeedEvaporativeCondenserAirFlowRate() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedEvaporativeCondenserAirFlowRate();
-  }
+
   bool CoilCoolingDXTwoSpeed::setLowSpeedEvaporativeCondenserAirFlowRate(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setLowSpeedEvaporativeCondenserAirFlowRate(value);
   }
+
   bool CoilCoolingDXTwoSpeed::setLowSpeedEvaporativeCondenserAirFlowRate(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setLowSpeedEvaporativeCondenserAirFlowRate(value);
   }
@@ -1230,12 +1239,11 @@ namespace model {
   OptionalDouble CoilCoolingDXTwoSpeed::lowSpeedEvaporativeCondenserPumpRatedPowerConsumption() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedEvaporativeCondenserPumpRatedPowerConsumption();
   }
-  OptionalDouble CoilCoolingDXTwoSpeed::getLowSpeedEvaporativeCondenserPumpRatedPowerConsumption() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->lowSpeedEvaporativeCondenserPumpRatedPowerConsumption();
-  }
+
   bool CoilCoolingDXTwoSpeed::setLowSpeedEvaporativeCondenserPumpRatedPowerConsumption(OptionalDouble value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setLowSpeedEvaporativeCondenserPumpRatedPowerConsumption(value);
   }
+
   bool CoilCoolingDXTwoSpeed::setLowSpeedEvaporativeCondenserPumpRatedPowerConsumption(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setLowSpeedEvaporativeCondenserPumpRatedPowerConsumption(value);
   }
@@ -1249,23 +1257,19 @@ namespace model {
   //setCondensateCollectionWaterStorageTankName
 
   //  N15, \field Basin Heater Capacity
-  OptionalDouble CoilCoolingDXTwoSpeed::basinHeaterCapacity() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->basinHeaterCapacity();
-  }
-  OptionalDouble CoilCoolingDXTwoSpeed::getBasinHeaterCapacity() const {
+  double CoilCoolingDXTwoSpeed::basinHeaterCapacity() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->basinHeaterCapacity();
   }
+
   bool CoilCoolingDXTwoSpeed::setBasinHeaterCapacity(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setBasinHeaterCapacity(value);
   }
 
   //  N16, \field Basin Heater Setpoint Temperature
-  OptionalDouble CoilCoolingDXTwoSpeed::basinHeaterSetpointTemperature() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->basinHeaterSetpointTemperature();
-  }
-  OptionalDouble CoilCoolingDXTwoSpeed::getBasinHeaterSetpointTemperature() const {
+  double CoilCoolingDXTwoSpeed::basinHeaterSetpointTemperature() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->basinHeaterSetpointTemperature();
   }
+
   bool CoilCoolingDXTwoSpeed::setBasinHeaterSetpointTemperature(double value) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setBasinHeaterSetpointTemperature(value);
   }
@@ -1274,9 +1278,7 @@ namespace model {
   OptionalSchedule CoilCoolingDXTwoSpeed::basinHeaterOperatingSchedule() const {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->basinHeaterOperatingSchedule();
   }
-  OptionalSchedule CoilCoolingDXTwoSpeed::getBasinHeaterOperatingSchedule() const {
-    return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->basinHeaterOperatingSchedule();
-  }
+
   bool CoilCoolingDXTwoSpeed::setBasinHeaterOperatingSchedule(Schedule& schedule) {
     return getImpl<detail::CoilCoolingDXTwoSpeed_Impl>()->setBasinHeaterOperatingSchedule(schedule);
   }
diff --git a/src/model/CoilCoolingDXTwoSpeed.hpp b/src/model/CoilCoolingDXTwoSpeed.hpp
index b30ca9d0dbe..e458c3b36c9 100644
--- a/src/model/CoilCoolingDXTwoSpeed.hpp
+++ b/src/model/CoilCoolingDXTwoSpeed.hpp
@@ -89,181 +89,100 @@ namespace model {
     /** Returns the Schedule referred to by the AvailabilitySchedule field. **/
     Schedule availabilitySchedule() const;
 
-    /** \deprecated */
-    Schedule getAvailabilitySchedule() const;
-
     /** Returns the value of the RatedHighSpeedTotalCoolingCapacity field.
    *  Optional == false means "Autocalculate" */
     boost::optional<double> ratedHighSpeedTotalCoolingCapacity() const;
 
-    /** \deprecated */
-    boost::optional<double> getRatedHighSpeedTotalCoolingCapacity() const;
-
     /** Returns the value of the RatedHighSpeedSensibleHeatRatio field.
    *   Optional == false means "Autocalculate" */
     boost::optional<double> ratedHighSpeedSensibleHeatRatio() const;
 
-    /** \deprecated */
-    boost::optional<double> getRatedHighSpeedSensibleHeatRatio() const;
-
     /** Returns the value of the RatedHighSpeedCOP field. **/
-    boost::optional<double> ratedHighSpeedCOP() const;
-
-    /** \deprecated **/
-    boost::optional<double> getRatedHighSpeedCOP() const;
+    double ratedHighSpeedCOP() const;
 
     /** Returns the value of the RatedHighSpeedAirFlowRate field.
    *  Optional == false means "Autocalculate" */
     boost::optional<double> ratedHighSpeedAirFlowRate() const;
 
-    /** \deprecated */
-    boost::optional<double> getRatedHighSpeedAirFlowRate() const;
-
     /** Returns the Curve referred to by the
    *  TotalCoolingCapacityFunctionOfTemperatureCurveName field. */
     Curve totalCoolingCapacityFunctionOfTemperatureCurve() const;
 
-    /** \deprecated */
-    Curve getTotalCoolingCapacityFunctionOfTemperatureCurve() const;
-
     /** Returns the Curve referred to by the
    *  TotalCoolingCapacityFunctionOfFlowFractionCurveName field. */
     Curve totalCoolingCapacityFunctionOfFlowFractionCurve() const;
 
-    /** \deprecated */
-    Curve getTotalCoolingCapacityFunctionOfFlowFractionCurve() const;
-
     /** Returns the Curve referred to by the
    *  EnergyInputRatioFunctionOfTemperatureCurveName field. */
     Curve energyInputRatioFunctionOfTemperatureCurve() const;
 
-    /** \deprecated */
-    Curve getEnergyInputRatioFunctionOfTemperatureCurve() const;
-
     /** Returns the Curve referred to by the
    *  EnergyInputRatioFunctionOfFlowFractionCurveName field. */
     Curve energyInputRatioFunctionOfFlowFractionCurve() const;
 
-    /** \deprecated */
-    Curve getEnergyInputRatioFunctionOfFlowFractionCurve() const;
-
     /** Returns the Curve referred to by the PartLoadFractionCorrelationCurveName
    *  field. **/
     Curve partLoadFractionCorrelationCurve() const;
 
-    /** \deprecated */
-    Curve getPartLoadFractionCorrelationCurve() const;
-
     /** Returns the value of the RatedLowSpeedTotalCoolingCapacity field.
    *  Optional == false means "Autocalculate" */
     boost::optional<double> ratedLowSpeedTotalCoolingCapacity() const;
 
-    /** \deprecated */
-    boost::optional<double> getRatedLowSpeedTotalCoolingCapacity() const;
-
     /** Returns the value of the RatedLowSpeedSensibleHeatRatio field.
    *  Optional == false means "Autocalculate" */
     boost::optional<double> ratedLowSpeedSensibleHeatRatio() const;
 
-    /** \deprecated */
-    boost::optional<double> getRatedLowSpeedSensibleHeatRatio() const;
-
     /** Returns the value of the RatedLowSpeedCOP field. */
-    boost::optional<double> ratedLowSpeedCOP() const;
-
-    /** \deprecated */
-    boost::optional<double> getRatedLowSpeedCOP() const;
+    double ratedLowSpeedCOP() const;
 
     /** Returns the value of the RatedLowSpeedAirFlowRate field.
    *  Optional == false means "Autocalculate" */
     boost::optional<double> ratedLowSpeedAirFlowRate() const;
 
-    /** \deprecated */
-    boost::optional<double> getRatedLowSpeedAirFlowRate() const;
-
     /** Returns the Curve referred to by the
    *  TotalCoolingCapacityFunctionOfTemperatureCurveName field. */
     Curve lowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve() const;
 
-    /** \deprecated */
-    Curve getLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve() const;
-
     /** Returns the Curve referred to by the
    *  LowSpeedEnergyInputRatioFunctionOfTemperatureCurveName field. */
     Curve lowSpeedEnergyInputRatioFunctionOfTemperatureCurve() const;
 
-    /** \deprecated */
-    Curve getLowSpeedEnergyInputRatioFunctionOfTemperatureCurve() const;
-
     boost::optional<std::string> condenserAirInletNodeName() const;
 
-    /** \deprecated */
-    boost::optional<std::string> getCondenserAirInletNodeName() const;
-
     /** Returns the value of the CondenserType field. */
     std::string condenserType() const;
 
-    /** \deprecated */
-    std::string getCondenserType() const;
-
     /** Returns the value of the HighSpeedEvaporativeCondenserEffectiveness field. */
-    boost::optional<double> highSpeedEvaporativeCondenserEffectiveness() const;
-
-    /** \deprecated */
-    boost::optional<double> getHighSpeedEvaporativeCondenserEffectiveness() const;
+    double highSpeedEvaporativeCondenserEffectiveness() const;
 
     /** Returns the value of the HighSpeedEvaporativeCondenserAirFlowRate field.
    *  optional == flase means "autosize" */
     boost::optional<double> highSpeedEvaporativeCondenserAirFlowRate() const;
 
-    /** \deprecated */
-    boost::optional<double> getHighSpeedEvaporativeCondenserAirFlowRate() const;
-
     /** Returns the value of the HighSpeedEvaporativeCondenserPumpRatedPowerConsumption field.
    *  optional == flase means "autosize" */
     boost::optional<double> highSpeedEvaporativeCondenserPumpRatedPowerConsumption() const;
 
-    /** \deprecated */
-    boost::optional<double> getHighSpeedEvaporativeCondenserPumpRatedPowerConsumption() const;
-
     /** Returns the value of the LowSpeedEvaporativeCondenserEffectiveness field. */
-    boost::optional<double> lowSpeedEvaporativeCondenserEffectiveness() const;
-
-    /** \deprecated */
-    boost::optional<double> getLowSpeedEvaporativeCondenserEffectiveness() const;
+    double lowSpeedEvaporativeCondenserEffectiveness() const;
 
     /** Returns the value of the LowSpeedEvaporativeCondenserAirFlowRate field.
    *  optional == flase means "autosize" */
     boost::optional<double> lowSpeedEvaporativeCondenserAirFlowRate() const;
 
-    /** \deprecated */
-    boost::optional<double> getLowSpeedEvaporativeCondenserAirFlowRate() const;
-
     /** Returns the value of the LowSpeedEvaporativeCondenserPumpRatedPowerConsumption field.
    *  optional == flase means "autosize" */
     boost::optional<double> lowSpeedEvaporativeCondenserPumpRatedPowerConsumption() const;
 
-    /** \deprecated */
-    boost::optional<double> getLowSpeedEvaporativeCondenserPumpRatedPowerConsumption() const;
-
     /** Returns the value of the BasinHeaterCapacity field. **/
-    boost::optional<double> basinHeaterCapacity() const;
-
-    /** \deprecated **/
-    boost::optional<double> getBasinHeaterCapacity() const;
+    double basinHeaterCapacity() const;
 
     /** Returns the value of the BasinHeaterSetpointTemperature field. **/
-    boost::optional<double> basinHeaterSetpointTemperature() const;
-
-    /** \deprecated **/
-    boost::optional<double> getBasinHeaterSetpointTemperature() const;
+    double basinHeaterSetpointTemperature() const;
 
     /** Returns the Schedule referred to by the BasinHeaterOperatingSchedule field. **/
     boost::optional<Schedule> basinHeaterOperatingSchedule() const;
 
-    /** \deprecated */
-    boost::optional<Schedule> getBasinHeaterOperatingSchedule() const;
-
     double minimumOutdoorDryBulbTemperatureforCompressorOperation() const;
 
     double unitInternalStaticAirPressure() const;
diff --git a/src/model/CoilCoolingDXTwoSpeed_Impl.hpp b/src/model/CoilCoolingDXTwoSpeed_Impl.hpp
index a857e1af064..32314814a80 100644
--- a/src/model/CoilCoolingDXTwoSpeed_Impl.hpp
+++ b/src/model/CoilCoolingDXTwoSpeed_Impl.hpp
@@ -95,7 +95,7 @@ namespace model {
 
       boost::optional<double> ratedHighSpeedSensibleHeatRatio() const;
 
-      boost::optional<double> ratedHighSpeedCOP() const;
+      double ratedHighSpeedCOP() const;
 
       boost::optional<double> ratedHighSpeedAirFlowRate() const;
 
@@ -113,7 +113,7 @@ namespace model {
 
       boost::optional<double> ratedLowSpeedSensibleHeatRatio() const;
 
-      boost::optional<double> ratedLowSpeedCOP() const;
+      double ratedLowSpeedCOP() const;
 
       boost::optional<double> ratedLowSpeedAirFlowRate() const;
 
@@ -125,21 +125,21 @@ namespace model {
 
       std::string condenserType() const;
 
-      boost::optional<double> highSpeedEvaporativeCondenserEffectiveness() const;
+      double highSpeedEvaporativeCondenserEffectiveness() const;
 
       boost::optional<double> highSpeedEvaporativeCondenserAirFlowRate() const;
 
       boost::optional<double> highSpeedEvaporativeCondenserPumpRatedPowerConsumption() const;
 
-      boost::optional<double> lowSpeedEvaporativeCondenserEffectiveness() const;
+      double lowSpeedEvaporativeCondenserEffectiveness() const;
 
       boost::optional<double> lowSpeedEvaporativeCondenserAirFlowRate() const;
 
       boost::optional<double> lowSpeedEvaporativeCondenserPumpRatedPowerConsumption() const;
 
-      boost::optional<double> basinHeaterCapacity() const;
+      double basinHeaterCapacity() const;
 
-      boost::optional<double> basinHeaterSetpointTemperature() const;
+      double basinHeaterSetpointTemperature() const;
 
       boost::optional<Schedule> basinHeaterOperatingSchedule() const;
 
diff --git a/src/sdd/MapHVAC.cpp b/src/sdd/MapHVAC.cpp
index 548d478e795..93e23288bdc 100644
--- a/src/sdd/MapHVAC.cpp
+++ b/src/sdd/MapHVAC.cpp
@@ -8641,7 +8641,7 @@ namespace sdd {
     // DXEER
     if (auto cop = coil.ratedCOP()) {
       auto r = 0.12;
-      auto eer = (cop.get() * (1 - r) - r) * 3.413;
+      auto eer = (cop * (1 - r) - r) * 3.413;
 
       auto dxEERElement = result.append_child("DXEER");
       dxEERElement.text() = openstudio::string_conversions::number(eer).c_str();


Test patch:
diff --git a/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp b/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp
index 782a16d6647..503b24bd500 100644
--- a/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp
+++ b/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp
@@ -58,6 +58,12 @@ TEST_F(ModelFixture, CoilCoolingDXSingleSpeed_RatedTotalCoolingCapacity_GettersS
                                 energyInputRatioFunctionofTemperatureCurve, energyInputRatioFunctionofFlowFractionCurve,
                                 partLoadFractionCorrelationCurve);
 
+  EXPECT_TRUE(coil.isRatedTotalCoolingCapacityAutosized());
+  EXPECT_TRUE(coil.isRatedSensibleHeatRatioAutosized());
+  EXPECT_TRUE(coil.isRatedAirFlowRateAutosized());
+  EXPECT_TRUE(coil.isEvaporativeCondenserAirFlowRateAutosized());
+  EXPECT_TRUE(coil.isEvaporativeCondenserPumpRatedPowerConsumptionAutosized());
+
   coil.setRatedTotalCoolingCapacity(1.0);
   coil.setRatedSensibleHeatRatio(0.6);
   coil.setRatedCOP(3.6);
@@ -76,19 +82,19 @@ TEST_F(ModelFixture, CoilCoolingDXSingleSpeed_RatedTotalCoolingCapacity_GettersS
 
   EXPECT_EQ(coil.ratedTotalCoolingCapacity().get(), 1.0);
   EXPECT_EQ(coil.ratedSensibleHeatRatio().get(), 0.6);
-  EXPECT_EQ(coil.ratedCOP().get(), 3.6);
+  EXPECT_EQ(coil.ratedCOP(), 3.6);
   EXPECT_EQ(coil.ratedAirFlowRate().get(), 1.1);
-  EXPECT_EQ(coil.ratedEvaporatorFanPowerPerVolumeFlowRate().get(), 600.0);
-  EXPECT_EQ(coil.nominalTimeForCondensateRemovalToBegin().get(), 50.0);
-  EXPECT_EQ(coil.ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity().get(), 3.0);
-  EXPECT_EQ(coil.maximumCyclingRate().get(), 3.2);
-  EXPECT_EQ(coil.latentCapacityTimeConstant().get(), 499.8);
-  EXPECT_EQ(coil.evaporativeCondenserEffectiveness().get(), 0.8);
+  EXPECT_EQ(coil.ratedEvaporatorFanPowerPerVolumeFlowRate(), 600.0);
+  EXPECT_EQ(coil.nominalTimeForCondensateRemovalToBegin(), 50.0);
+  EXPECT_EQ(coil.ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(), 3.0);
+  EXPECT_EQ(coil.maximumCyclingRate(), 3.2);
+  EXPECT_EQ(coil.latentCapacityTimeConstant(), 499.8);
+  EXPECT_EQ(coil.evaporativeCondenserEffectiveness(), 0.8);
   EXPECT_EQ(coil.evaporativeCondenserAirFlowRate().get(), 1.2);
   EXPECT_EQ(coil.evaporativeCondenserPumpRatedPowerConsumption().get(), 1.3);
-  EXPECT_EQ(coil.maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation().get(), 1.4);
-  EXPECT_EQ(coil.basinHeaterCapacity().get(), 1.5);
-  EXPECT_EQ(coil.basinHeaterSetpointTemperature().get(), 2.5);
+  EXPECT_EQ(coil.maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(), 1.4);
+  EXPECT_EQ(coil.basinHeaterCapacity(), 1.5);
+  EXPECT_EQ(coil.basinHeaterSetpointTemperature(), 2.5);
 
   // #3976 - Minimum Outdoor Dry-Bulb Temperature for Compressor Operation
   // IDD Default
diff --git a/src/model/test/CoilCoolingDXTwoSpeed_GTest.cpp b/src/model/test/CoilCoolingDXTwoSpeed_GTest.cpp
index 22346ea6064..ce21ef8358f 100644
--- a/src/model/test/CoilCoolingDXTwoSpeed_GTest.cpp
+++ b/src/model/test/CoilCoolingDXTwoSpeed_GTest.cpp
@@ -96,13 +96,13 @@ TEST_F(ModelFixture, CoilCoolingDXTwoSpeed_CoilCoolingDXTwoSpeed) {
   CoilCoolingDXTwoSpeed coil(m, s, ccfot, ccfof, eirfot, eirfof, plf, lsccfot, lseirfot);
 
   //ASSERT_EQ("Autosize",coil.getRatedHighSpeedTotalCoolingCapacity().get());
-  ASSERT_EQ(3, coil.getRatedHighSpeedCOP().get());
-  ASSERT_EQ(3, coil.getRatedLowSpeedCOP().get());
-  ASSERT_EQ(0, coil.getHighSpeedEvaporativeCondenserEffectiveness().get());
-  ASSERT_EQ(0, coil.getLowSpeedEvaporativeCondenserEffectiveness().get());
-  ASSERT_EQ(0, coil.getBasinHeaterCapacity().get());
-  ASSERT_EQ(10, coil.getBasinHeaterSetpointTemperature().get());
-  ASSERT_EQ("AirCooled", coil.getCondenserType());
+  ASSERT_EQ(3, coil.ratedHighSpeedCOP());
+  ASSERT_EQ(3, coil.ratedLowSpeedCOP());
+  ASSERT_EQ(0, coil.highSpeedEvaporativeCondenserEffectiveness());
+  ASSERT_EQ(0, coil.lowSpeedEvaporativeCondenserEffectiveness());
+  ASSERT_EQ(0, coil.basinHeaterCapacity());
+  ASSERT_EQ(10, coil.basinHeaterSetpointTemperature());
+  ASSERT_EQ("AirCooled", coil.condenserType());
 }
 
 //Test cloning the coil
@@ -147,25 +147,25 @@ TEST_F(ModelFixture, CoilCoolingDXTwoSpeed_Clone) {
   //Clone into the same model
   CoilCoolingDXTwoSpeed coilClone = coil.clone(m).cast<CoilCoolingDXTwoSpeed>();
 
-  ASSERT_EQ(1, coilClone.getTotalCoolingCapacityFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
-  ASSERT_EQ(2, coilClone.getTotalCoolingCapacityFunctionOfFlowFractionCurve().cast<CurveCubic>().coefficient1Constant());
-  ASSERT_EQ(3, coilClone.getEnergyInputRatioFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
-  ASSERT_EQ(4, coilClone.getEnergyInputRatioFunctionOfFlowFractionCurve().cast<CurveQuadratic>().coefficient1Constant());
-  ASSERT_EQ(5, coilClone.getPartLoadFractionCorrelationCurve().cast<CurveCubic>().coefficient1Constant());
-  ASSERT_EQ(6, coilClone.getLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
-  ASSERT_EQ(7, coilClone.getLowSpeedEnergyInputRatioFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
+  ASSERT_EQ(1, coilClone.totalCoolingCapacityFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
+  ASSERT_EQ(2, coilClone.totalCoolingCapacityFunctionOfFlowFractionCurve().cast<CurveCubic>().coefficient1Constant());
+  ASSERT_EQ(3, coilClone.energyInputRatioFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
+  ASSERT_EQ(4, coilClone.energyInputRatioFunctionOfFlowFractionCurve().cast<CurveQuadratic>().coefficient1Constant());
+  ASSERT_EQ(5, coilClone.partLoadFractionCorrelationCurve().cast<CurveCubic>().coefficient1Constant());
+  ASSERT_EQ(6, coilClone.lowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
+  ASSERT_EQ(7, coilClone.lowSpeedEnergyInputRatioFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
 
   //Clone into another model
   Model m2;
   CoilCoolingDXTwoSpeed coilClone2 = coil.clone(m2).cast<CoilCoolingDXTwoSpeed>();
 
-  ASSERT_EQ(1, coilClone2.getTotalCoolingCapacityFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
-  ASSERT_EQ(2, coilClone2.getTotalCoolingCapacityFunctionOfFlowFractionCurve().cast<CurveCubic>().coefficient1Constant());
-  ASSERT_EQ(3, coilClone2.getEnergyInputRatioFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
-  ASSERT_EQ(4, coilClone2.getEnergyInputRatioFunctionOfFlowFractionCurve().cast<CurveQuadratic>().coefficient1Constant());
-  ASSERT_EQ(5, coilClone2.getPartLoadFractionCorrelationCurve().cast<CurveCubic>().coefficient1Constant());
-  ASSERT_EQ(6, coilClone2.getLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
-  ASSERT_EQ(7, coilClone2.getLowSpeedEnergyInputRatioFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
+  ASSERT_EQ(1, coilClone2.totalCoolingCapacityFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
+  ASSERT_EQ(2, coilClone2.totalCoolingCapacityFunctionOfFlowFractionCurve().cast<CurveCubic>().coefficient1Constant());
+  ASSERT_EQ(3, coilClone2.energyInputRatioFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
+  ASSERT_EQ(4, coilClone2.energyInputRatioFunctionOfFlowFractionCurve().cast<CurveQuadratic>().coefficient1Constant());
+  ASSERT_EQ(5, coilClone2.partLoadFractionCorrelationCurve().cast<CurveCubic>().coefficient1Constant());
+  ASSERT_EQ(6, coilClone2.lowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
+  ASSERT_EQ(7, coilClone2.lowSpeedEnergyInputRatioFunctionOfTemperatureCurve().cast<CurveBiquadratic>().coefficient1Constant());
 }
 
 //Test the methods that set and get all the fields
@@ -189,23 +189,23 @@ TEST_F(ModelFixture, CoilCoolingDXTwoSpeed_SetGetFields) {
   //  A2 , \field Availability Schedule Name
   ScheduleCompact availSch(m);
   coil.setAvailabilitySchedule(availSch);
-  ASSERT_EQ(availSch, coil.getAvailabilitySchedule());
+  ASSERT_EQ(availSch, coil.availabilitySchedule());
 
   //  N1 , \field Rated High Speed Total Cooling Capacity
   coil.setRatedHighSpeedTotalCoolingCapacity(999);
-  ASSERT_EQ(999, coil.getRatedHighSpeedTotalCoolingCapacity().get());
+  ASSERT_EQ(999, coil.ratedHighSpeedTotalCoolingCapacity().get());
 
   //  N2 , \field Rated High Speed Sensible Heat Ratio
   coil.setRatedHighSpeedSensibleHeatRatio(0.999);
-  ASSERT_EQ(0.999, coil.getRatedHighSpeedSensibleHeatRatio().get());
+  ASSERT_EQ(0.999, coil.ratedHighSpeedSensibleHeatRatio().get());
 
   //  N3 , \field Rated High Speed COP
   coil.setRatedHighSpeedCOP(0.999);
-  ASSERT_EQ(0.999, coil.getRatedHighSpeedCOP().get());
+  ASSERT_EQ(0.999, coil.ratedHighSpeedCOP());
 
   //  N4 , \field Rated High Speed Air Flow Rate
   coil.setRatedHighSpeedAirFlowRate(999);
-  ASSERT_EQ(999, coil.getRatedHighSpeedAirFlowRate().get());
+  ASSERT_EQ(999, coil.ratedHighSpeedAirFlowRate().get());
 
   //create some curves for testing
   CurveBiquadratic testBiquadratic(m);
@@ -215,91 +215,91 @@ TEST_F(ModelFixture, CoilCoolingDXTwoSpeed_SetGetFields) {
   //  A5 , \field Total Cooling Capacity Function of Temperature Curve Name
   //\object-list BiquadraticCurves
   ASSERT_TRUE(coil.setTotalCoolingCapacityFunctionOfTemperatureCurve(testBiquadratic));
-  ASSERT_EQ(testBiquadratic, coil.getTotalCoolingCapacityFunctionOfTemperatureCurve());
+  ASSERT_EQ(testBiquadratic, coil.totalCoolingCapacityFunctionOfTemperatureCurve());
 
   //  A6 , \field Total Cooling Capacity Function of Flow Fraction Curve Name
   //\object-list QuadraticCubicCurves
   ASSERT_TRUE(coil.setTotalCoolingCapacityFunctionOfFlowFractionCurve(testQuadratic));
-  ASSERT_EQ(testQuadratic, coil.getTotalCoolingCapacityFunctionOfFlowFractionCurve());
+  ASSERT_EQ(testQuadratic, coil.totalCoolingCapacityFunctionOfFlowFractionCurve());
   ASSERT_TRUE(coil.setTotalCoolingCapacityFunctionOfFlowFractionCurve(testCubic));
-  ASSERT_EQ(testCubic, coil.getTotalCoolingCapacityFunctionOfFlowFractionCurve());
+  ASSERT_EQ(testCubic, coil.totalCoolingCapacityFunctionOfFlowFractionCurve());
 
   //  A7 , \field Energy Input Ratio Function of Temperature Curve Name
   //\object-list BiquadraticCurves
   ASSERT_TRUE(coil.setEnergyInputRatioFunctionOfTemperatureCurve(testBiquadratic));
-  ASSERT_EQ(testBiquadratic, coil.getEnergyInputRatioFunctionOfTemperatureCurve());
+  ASSERT_EQ(testBiquadratic, coil.energyInputRatioFunctionOfTemperatureCurve());
 
   //  A8 , \field Energy Input Ratio Function of Flow Fraction Curve Name
   //\object-list QuadraticCubicCurves
   ASSERT_TRUE(coil.setEnergyInputRatioFunctionOfFlowFractionCurve(testQuadratic));
-  ASSERT_EQ(testQuadratic, coil.getEnergyInputRatioFunctionOfFlowFractionCurve());
+  ASSERT_EQ(testQuadratic, coil.energyInputRatioFunctionOfFlowFractionCurve());
   ASSERT_TRUE(coil.setEnergyInputRatioFunctionOfFlowFractionCurve(testCubic));
-  ASSERT_EQ(testCubic, coil.getEnergyInputRatioFunctionOfFlowFractionCurve());
+  ASSERT_EQ(testCubic, coil.energyInputRatioFunctionOfFlowFractionCurve());
 
   //  A9 , \field Part Load Fraction Correlation Curve Name
   //\object-list QuadraticCubicCurves
   ASSERT_TRUE(coil.setPartLoadFractionCorrelationCurve(testQuadratic));
-  ASSERT_EQ(testQuadratic, coil.getPartLoadFractionCorrelationCurve());
+  ASSERT_EQ(testQuadratic, coil.partLoadFractionCorrelationCurve());
   ASSERT_TRUE(coil.setPartLoadFractionCorrelationCurve(testCubic));
-  ASSERT_EQ(testCubic, coil.getPartLoadFractionCorrelationCurve());
+  ASSERT_EQ(testCubic, coil.partLoadFractionCorrelationCurve());
 
   //  N5 , \field Rated Low Speed Total Cooling Capacity
   coil.setRatedLowSpeedTotalCoolingCapacity(999);
-  ASSERT_EQ(999, coil.getRatedLowSpeedTotalCoolingCapacity().get());
+  ASSERT_EQ(999, coil.ratedLowSpeedTotalCoolingCapacity().get());
 
   //  N6 , \field Rated Low Speed Sensible Heat Ratio
   coil.setRatedLowSpeedSensibleHeatRatio(0.999);
-  ASSERT_EQ(0.999, coil.getRatedLowSpeedSensibleHeatRatio().get());
+  ASSERT_EQ(0.999, coil.ratedLowSpeedSensibleHeatRatio().get());
 
   //  N7 , \field Rated Low Speed COP
   coil.setRatedLowSpeedCOP(0.999);
-  ASSERT_EQ(0.999, coil.getRatedLowSpeedCOP().get());
+  ASSERT_EQ(0.999, coil.ratedLowSpeedCOP());
 
   //  N8 , \field Rated Low Speed Air Flow Rate
   coil.setRatedLowSpeedAirFlowRate(999);
-  ASSERT_EQ(999, coil.getRatedLowSpeedAirFlowRate().get());
+  ASSERT_EQ(999, coil.ratedLowSpeedAirFlowRate().get());
 
   //  A10, \field Low Speed Total Cooling Capacity Function of Temperature Curve Name
   //\object-list BiquadraticCurves
   ASSERT_TRUE(coil.setLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve(testBiquadratic));
-  ASSERT_EQ(testBiquadratic, coil.getLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve());
+  ASSERT_EQ(testBiquadratic, coil.lowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve());
 
   //  A11, \field Low Speed Energy Input Ratio Function of Temperature Curve Name
   //\object-list BiquadraticCurves
   ASSERT_TRUE(coil.setLowSpeedEnergyInputRatioFunctionOfTemperatureCurve(testBiquadratic));
-  ASSERT_EQ(testBiquadratic, coil.getLowSpeedEnergyInputRatioFunctionOfTemperatureCurve());
+  ASSERT_EQ(testBiquadratic, coil.lowSpeedEnergyInputRatioFunctionOfTemperatureCurve());
 
   //  A12, \field Condenser Air Inlet Node Name
   coil.setCondenserAirInletNodeName("testNode");
-  ASSERT_EQ("testNode", coil.getCondenserAirInletNodeName().get());
+  ASSERT_EQ("testNode", coil.condenserAirInletNodeName().get());
 
   //  A13, \field Condenser Type
   coil.setCondenserType("EvaporativelyCooled");
-  ASSERT_EQ("EvaporativelyCooled", coil.getCondenserType());
+  ASSERT_EQ("EvaporativelyCooled", coil.condenserType());
 
   //   N9, \field High Speed Evaporative Condenser Effectiveness
   coil.setHighSpeedEvaporativeCondenserEffectiveness(0.999);
-  ASSERT_EQ(0.999, coil.getHighSpeedEvaporativeCondenserEffectiveness().get());
+  ASSERT_EQ(0.999, coil.highSpeedEvaporativeCondenserEffectiveness());
 
   //  N10, \field High Speed Evaporative Condenser Air Flow Rate
   coil.setHighSpeedEvaporativeCondenserAirFlowRate(999);
-  ASSERT_EQ(999, coil.getHighSpeedEvaporativeCondenserAirFlowRate().get());
+  ASSERT_EQ(999, coil.highSpeedEvaporativeCondenserAirFlowRate().get());
 
   //  N11, \field High Speed Evaporative Condenser Pump Rated Power Consumption
   coil.setHighSpeedEvaporativeCondenserPumpRatedPowerConsumption(999);
-  ASSERT_EQ(999, coil.getHighSpeedEvaporativeCondenserPumpRatedPowerConsumption().get());
+  ASSERT_EQ(999, coil.highSpeedEvaporativeCondenserPumpRatedPowerConsumption().get());
 
   //  N12, \field Low Speed Evaporative Condenser Effectiveness
   coil.setLowSpeedEvaporativeCondenserEffectiveness(0.999);
-  ASSERT_EQ(0.999, coil.getLowSpeedEvaporativeCondenserEffectiveness().get());
+  ASSERT_EQ(0.999, coil.lowSpeedEvaporativeCondenserEffectiveness());
 
   //  N13, \field Low Speed Evaporative Condenser Air Flow Rate
   coil.setLowSpeedEvaporativeCondenserAirFlowRate(999);
-  ASSERT_EQ(999, coil.getLowSpeedEvaporativeCondenserAirFlowRate().get());
+  ASSERT_EQ(999, coil.lowSpeedEvaporativeCondenserAirFlowRate().get());
 
   //  N14, \field Low Speed Evaporative Condenser Pump Rated Power Consumption
   coil.setLowSpeedEvaporativeCondenserPumpRatedPowerConsumption(999);
-  ASSERT_EQ(999, coil.getLowSpeedEvaporativeCondenserPumpRatedPowerConsumption().get());
+  ASSERT_EQ(999, coil.lowSpeedEvaporativeCondenserPumpRatedPowerConsumption().get());
 
   //  A14, \field Supply Water Storage Tank Name
   //getSupplyWaterStorageTankName
@@ -311,16 +311,16 @@ TEST_F(ModelFixture, CoilCoolingDXTwoSpeed_SetGetFields) {
 
   //  N15, \field Basin Heater Capacity
   coil.setBasinHeaterCapacity(999);
-  ASSERT_EQ(999, coil.getBasinHeaterCapacity().get());
+  ASSERT_EQ(999, coil.basinHeaterCapacity());
 
   //  N16, \field Basin Heater Setpoint Temperature
   coil.setBasinHeaterSetpointTemperature(35);
-  ASSERT_EQ(35, coil.getBasinHeaterSetpointTemperature().get());
+  ASSERT_EQ(35, coil.basinHeaterSetpointTemperature());
 
   //  A16; \field Basin Heater Operating Schedule Name
   ScheduleCompact basinSch(m);
   coil.setBasinHeaterOperatingSchedule(basinSch);
-  ASSERT_EQ(basinSch, coil.getBasinHeaterOperatingSchedule().get());
+  ASSERT_EQ(basinSch, coil.basinHeaterOperatingSchedule().get());
 
   // #3976 - Minimum Outdoor Dry-Bulb Temperature for Compressor Operation
   // IDD Default