Repository: NREL/OpenStudio (language: python)

Issue:
AirLoopHVACUnitarySystem set Method During XXX Operation - option, 2
Pull request overview
---------------------

 - Fixes #ISSUENUMBERHERE (IF THIS IS A DEFECT)

<!--- DESCRIBE PURPOSE OF THIS PULL REQUEST -->

<!--- Please read [OpenStudio Pull Requests](https://github.com/NREL/OpenStudio/wiki/OpenStudio-Pull-Requests) to better understand the OpenStudio Pull Request protocol. -->

### Pull Request Author

<!--- Add to this list or remove from it as applicable.  This is a simple templated set of guidelines. -->

 - [ ] Model API Changes / Additions
 - [ ] Any new or modified fields have been implemented in the EnergyPlus ForwardTranslator (and ReverseTranslator as appropriate)
 - [ ] Model API methods are tested (in `src/model/test`)
 - [ ] EnergyPlus ForwardTranslator Tests (in `src/energyplus/Test`)
 - [ ] If a new object or method, added a test in NREL/OpenStudio-resources: Add Link
 - [ ] If needed, added VersionTranslation rules for the objects (`src/osversion/VersionTranslator.cpp`)
 - [ ] Verified that C# bindings built fine on Windows, partial classes used as needed, etc.
 - [ ] All new and existing tests passes
 - [ ] If methods have been deprecated, update rest of code to use the new methods

**Labels:**

 - [ ] If change to an IDD file, add the label `IDDChange`
 - [ ] If breaking existing API, add the label `APIChange`
 - [ ] If deemed ready, add label `Pull Request - Ready for CI` so that CI builds your PR

### Review Checklist

This will not be exhaustively relevant to every PR.
 - [ ] Perform a Code Review on GitHub
 - [ ] Code Style, strip trailing whitespace, etc.
 - [ ] All related changes have been implemented: model changes, model tests, FT changes, FT tests, VersionTranslation, OS App
 - [ ] Labeling is ok
 - [ ] If defect, verify by running develop branch and reproducing defect, then running PR and reproducing fix
 - [ ] If feature, test running new feature, try creative ways to break it
 - [ ] CI status: all green or justified



Discussion / hints:

Fix patch:
diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd
index c5721bd7bef..6efd3a1187c 100644
--- a/resources/model/OpenStudio.idd
+++ b/resources/model/OpenStudio.idd
@@ -11902,6 +11902,7 @@ OS:AirLoopHVAC:UnitarySystem,
        \key FlowPerFloorArea
        \key FractionOfAutosizedCoolingValue
        \key FlowPerCoolingCapacity
+       \default None
        \note Enter the method used to determine the cooling supply air volume flow rate.
        \note None is used when a cooling coil is not included in the unitary system or this field may be blank.
        \note SupplyAirFlowRate is selected when the magnitude of the supply air volume is used.
@@ -11946,6 +11947,7 @@ OS:AirLoopHVAC:UnitarySystem,
        \key FlowPerFloorArea
        \key FractionOfAutosizedHeatingValue
        \key FlowPerHeatingCapacity
+       \default None
        \note Enter the method used to determine the heating supply air volume flow rate.
        \note None is used when a heating coil is not included in the unitary system or this field may be blank.
        \note SupplyAirFlowRate is selected when the magnitude of the supply air volume is used.
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp
index 71466fe0d57..e087090796b 100644
--- a/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateAirLoopHVACUnitarySystem.cpp
@@ -197,6 +197,34 @@ namespace energyplus {
         unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingCoilObjectType, _heatingCoil->iddObject().name());
         unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingCoilName, _heatingCoil->name().get());
       }
+
+      // Supply Air Flow Rate Method During Heating Operation
+      unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRateMethod,
+                              modelObject.supplyAirFlowRateMethodDuringHeatingOperation());
+
+      // Supply Air Flow Rate During Heating Operation
+      if (modelObject.isSupplyAirFlowRateDuringHeatingOperationAutosized()) {
+        unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRate, "Autosize");
+      } else if (auto val_ = modelObject.supplyAirFlowRateDuringHeatingOperation()) {
+        unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRate, val_.get());
+      }
+
+      // Supply Air Flow Rate Per Floor Area during Heating Operation
+      if (auto val_ = modelObject.supplyAirFlowRatePerFloorAreaduringHeatingOperation()) {
+        unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRatePerFloorArea, val_.get());
+      }
+
+      // Fraction of Autosized Design Heating Supply Air Flow Rate
+      if (auto val_ = modelObject.fractionofAutosizedDesignHeatingSupplyAirFlowRate()) {
+        unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingFractionofAutosizedHeatingSupplyAirFlowRate, val_.get());
+      }
+
+      // Design Supply Air Flow Rate Per Unit of Capacity During Heating Operation
+      if (auto val_ = modelObject.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation()) {
+        unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRatePerUnitofCapacity, val_.get());
+      }
+    } else {
+      unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRateMethod, "None");
     }
 
     // DX Heating Coil Sizing Ratio
@@ -217,6 +245,34 @@ namespace energyplus {
         unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingCoilObjectType, _coolingCoil->iddObject().name());
         unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingCoilName, _coolingCoil->name().get());
       }
+
+      // Supply Air Flow Rate Method During Cooling Operation
+      unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRateMethod,
+                              modelObject.supplyAirFlowRateMethodDuringCoolingOperation());
+
+      // Supply Air Flow Rate During Cooling Operation
+      if (modelObject.isSupplyAirFlowRateDuringCoolingOperationAutosized()) {
+        unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRate, "Autosize");
+      } else if (auto val_ = modelObject.supplyAirFlowRateDuringCoolingOperation()) {
+        unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRate, val_.get());
+      }
+
+      // Supply Air Flow Rate Per Floor Area During Cooling Operation
+      if (auto val_ = modelObject.supplyAirFlowRatePerFloorAreaDuringCoolingOperation()) {
+        unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRatePerFloorArea, val_.get());
+      }
+
+      // Fraction of Autosized Design Cooling Supply Air Flow Rate
+      if (auto val_ = modelObject.fractionofAutosizedDesignCoolingSupplyAirFlowRate()) {
+        unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingFractionofAutosizedCoolingSupplyAirFlowRate, val_.get());
+      }
+
+      // Design Supply Air Flow Rate Per Unit of Capacity During Cooling Operation
+      if (auto val_ = modelObject.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation()) {
+        unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRatePerUnitofCapacity, val_.get());
+      }
+    } else {
+      unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRateMethod, "None");
     }
 
     // Use DOAS DX Cooling Coil
@@ -252,68 +308,6 @@ namespace energyplus {
       }
     }
 
-    // Supply Air Flow Rate Method During Cooling Operation
-    s = modelObject.supplyAirFlowRateMethodDuringCoolingOperation();
-    if (s) {
-      unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRateMethod, s.get());
-    }
-
-    // Supply Air Flow Rate During Cooling Operation
-    if (modelObject.isSupplyAirFlowRateDuringCoolingOperationAutosized()) {
-      unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRate, "Autosize");
-    } else if ((d = modelObject.supplyAirFlowRateDuringCoolingOperation())) {
-      unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRate, d.get());
-    }
-
-    // Supply Air Flow Rate Per Floor Area During Cooling Operation
-    d = modelObject.supplyAirFlowRatePerFloorAreaDuringCoolingOperation();
-    if (d) {
-      unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRatePerFloorArea, d.get());
-    }
-
-    // Fraction of Autosized Design Cooling Supply Air Flow Rate
-    d = modelObject.fractionofAutosizedDesignCoolingSupplyAirFlowRate();
-    if (d) {
-      unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingFractionofAutosizedCoolingSupplyAirFlowRate, d.get());
-    }
-
-    // Design Supply Air Flow Rate Per Unit of Capacity During Cooling Operation
-    d = modelObject.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
-    if (d) {
-      unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::CoolingSupplyAirFlowRatePerUnitofCapacity, d.get());
-    }
-
-    // Supply Air Flow Rate Method During Heating Operation
-    s = modelObject.supplyAirFlowRateMethodDuringHeatingOperation();
-    if (s) {
-      unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRateMethod, s.get());
-    }
-
-    // Supply Air Flow Rate During Heating Operation
-    if (modelObject.isSupplyAirFlowRateDuringHeatingOperationAutosized()) {
-      unitarySystem.setString(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRate, "Autosize");
-    } else if ((d = modelObject.supplyAirFlowRateDuringHeatingOperation())) {
-      unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRate, d.get());
-    }
-
-    // Supply Air Flow Rate Per Floor Area during Heating Operation
-    d = modelObject.supplyAirFlowRatePerFloorAreaduringHeatingOperation();
-    if (d) {
-      unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRatePerFloorArea, d.get());
-    }
-
-    // Fraction of Autosized Design Heating Supply Air Flow Rate
-    d = modelObject.fractionofAutosizedDesignHeatingSupplyAirFlowRate();
-    if (d) {
-      unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingFractionofAutosizedHeatingSupplyAirFlowRate, d.get());
-    }
-
-    // Design Supply Air Flow Rate Per Unit of Capacity During Heating Operation
-    d = modelObject.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
-    if (d) {
-      unitarySystem.setDouble(AirLoopHVAC_UnitarySystemFields::HeatingSupplyAirFlowRatePerUnitofCapacity, d.get());
-    }
-
     // Supply Air Flow Rate Method When No Cooling or Heating is Required
     s = modelObject.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired();
     if (s) {
diff --git a/src/model/AirLoopHVACUnitarySystem.cpp b/src/model/AirLoopHVACUnitarySystem.cpp
index e0fe2990e04..02fdd8168c2 100644
--- a/src/model/AirLoopHVACUnitarySystem.cpp
+++ b/src/model/AirLoopHVACUnitarySystem.cpp
@@ -24,11 +24,14 @@
 
 #include "../utilities/core/Assert.hpp"
 #include "../utilities/data/DataEnums.hpp"
+#include "utilities/core/Exception.hpp"
 
 #include <utilities/idd/IddFactory.hxx>
 #include <utilities/idd/OS_AirLoopHVAC_UnitarySystem_FieldEnums.hxx>
 #include <utilities/idd/IddEnums.hxx>
 
+#include "../utilities/core/DeprecatedHelpers.hpp"
+
 namespace openstudio {
 namespace model {
 
@@ -299,6 +302,10 @@ namespace model {
       return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName);
     }
 
+    bool AirLoopHVACUnitarySystem_Impl::hasHeatingCoil() const {
+      return !isEmpty(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName);
+    }
+
     boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::heatingCoil() const {
       return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName);
     }
@@ -313,6 +320,10 @@ namespace model {
       return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio);
     }
 
+    bool AirLoopHVACUnitarySystem_Impl::hasCoolingCoil() const {
+      return !isEmpty(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName);
+    }
+
     boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::coolingCoil() const {
       return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName);
     }
@@ -360,9 +371,10 @@ namespace model {
       return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::SupplementalHeatingCoilName);
     }
 
-    boost::optional<std::string> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringCoolingOperation() const {
-      // No default, and return uninitialized if empty
-      return getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, false, true);
+    std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringCoolingOperation() const {
+      boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, true);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateDuringCoolingOperation() const {
@@ -390,9 +402,10 @@ namespace model {
       return getDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, true);
     }
 
-    boost::optional<std::string> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringHeatingOperation() const {
-      // No default, and return uninitialized if empty
-      return getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, false, true);
+    std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringHeatingOperation() const {
+      boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, true);
+      OS_ASSERT(value);
+      return value.get();
     }
 
     boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateDuringHeatingOperation() const {
@@ -668,20 +681,23 @@ namespace model {
       OS_ASSERT(result);
     }
 
-    bool AirLoopHVACUnitarySystem_Impl::setHeatingCoil(const boost::optional<HVACComponent>& heatingCoil) {
-      bool result(false);
-      if (heatingCoil) {
-        result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, heatingCoil.get().handle());
-      } else {
-        resetHeatingCoil();
-        result = true;
+    bool AirLoopHVACUnitarySystem_Impl::setHeatingCoil(const HVACComponent& heatingCoil) {
+      const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, heatingCoil.handle());
+      if (openstudio::istringEqual("None", supplyAirFlowRateMethodDuringHeatingOperation())) {
+        autosizeSupplyAirFlowRateDuringHeatingOperation();
+        OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate"));
       }
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetHeatingCoil() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, "");
       OS_ASSERT(result);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("None"));
+      resetSupplyAirFlowRateDuringHeatingOperation();
+      resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
+      resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
     }
 
     bool AirLoopHVACUnitarySystem_Impl::setDXHeatingCoilSizingRatio(double dXHeatingCoilSizingRatio) {
@@ -694,25 +710,27 @@ namespace model {
       OS_ASSERT(result);
     }
 
-    bool AirLoopHVACUnitarySystem_Impl::setCoolingCoil(const boost::optional<HVACComponent>& coolingCoil) {
-      bool result(false);
-      if (coolingCoil) {
-        result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, coolingCoil.get().handle());
-      } else {
-        resetCoolingCoil();
-        result = true;
+    bool AirLoopHVACUnitarySystem_Impl::setCoolingCoil(const HVACComponent& coolingCoil) {
+      const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, coolingCoil.handle());
+      if (openstudio::istringEqual("None", supplyAirFlowRateMethodDuringCoolingOperation())) {
+        autosizeSupplyAirFlowRateDuringCoolingOperation();
+        OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate"));
       }
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetCoolingCoil() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, "");
       OS_ASSERT(result);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("None"));
+      resetSupplyAirFlowRateDuringCoolingOperation();
+      resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
+      resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
     }
 
     bool AirLoopHVACUnitarySystem_Impl::setUseDOASDXCoolingCoil(bool useDOASDXCoolingCoil) {
       return setBooleanFieldValue(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil, useDOASDXCoolingCoil);
-      ;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetUseDOASDXCoolingCoil() {
@@ -763,212 +781,170 @@ namespace model {
     }
 
     bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodDuringCoolingOperation(
-      boost::optional<std::string> supplyAirFlowRateMethodDuringCoolingOperation) {
-      bool result(false);
-      if (supplyAirFlowRateMethodDuringCoolingOperation) {
-        result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation,
-                           supplyAirFlowRateMethodDuringCoolingOperation.get());
-      } else {
-        resetSupplyAirFlowRateMethodDuringCoolingOperation();
-        result = true;
-      }
+      const std::string& supplyAirFlowRateMethodDuringCoolingOperation) {
+      const bool result =
+        setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, supplyAirFlowRateMethodDuringCoolingOperation);
       return result;
     }
 
-    void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateMethodDuringCoolingOperation() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, "");
-      OS_ASSERT(result);
-    }
-
-    bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringCoolingOperation(boost::optional<double> supplyAirFlowRateDuringCoolingOperation) {
-      bool result(false);
-      if (supplyAirFlowRateDuringCoolingOperation) {
-        result =
-          setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, supplyAirFlowRateDuringCoolingOperation.get());
-        boost::optional<std::string> supplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate");
-        result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation);
-      } else {
-        resetSupplyAirFlowRateDuringCoolingOperation();
-        result = true;
-      }
+    bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation) {
+      const bool result =
+        setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, supplyAirFlowRateDuringCoolingOperation);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate"));
+      // resetSupplyAirFlowRateDuringCoolingOperation();
+      resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
+      resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateDuringCoolingOperation() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, "");
       OS_ASSERT(result);
     }
 
     void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateDuringCoolingOperation() {
-      bool result;
-      result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, "Autosize");
-      boost::optional<std::string> supplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate");
-      result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation);
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, "Autosize");
       OS_ASSERT(result);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate"));
+      // resetSupplyAirFlowRateDuringCoolingOperation();
+      resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
+      resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
     }
 
     bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(
-      boost::optional<double> supplyAirFlowRatePerFloorAreaDuringCoolingOperation) {
-      bool result(false);
-      if (supplyAirFlowRatePerFloorAreaDuringCoolingOperation) {
-        result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation,
-                           supplyAirFlowRatePerFloorAreaDuringCoolingOperation.get());
-        boost::optional<std::string> supplyAirFlowRateMethodDuringCoolingOperation("FlowPerFloorArea");
-        result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation);
-      } else {
-        resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
-        result = true;
-      }
+      double supplyAirFlowRatePerFloorAreaDuringCoolingOperation) {
+      const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation,
+                                    supplyAirFlowRatePerFloorAreaDuringCoolingOperation);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FlowPerFloorArea"));
+      resetSupplyAirFlowRateDuringCoolingOperation();
+      // resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
+      resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, "");
       OS_ASSERT(result);
     }
 
-    bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignCoolingSupplyAirFlowRate(
-      boost::optional<double> fractionofAutosizedDesignCoolingSupplyAirFlowRate) {
-      bool result(false);
-      if (fractionofAutosizedDesignCoolingSupplyAirFlowRate) {
-        result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate,
-                           fractionofAutosizedDesignCoolingSupplyAirFlowRate.get());
-        boost::optional<std::string> supplyAirFlowRateMethodDuringCoolingOperation("FractionOfAutosizedCoolingValue");
-        result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation);
-      } else {
-        resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
-        result = true;
-      }
+    bool
+      AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate) {
+      const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate,
+                                    fractionofAutosizedDesignCoolingSupplyAirFlowRate);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FractionOfAutosizedCoolingValue"));
+      resetSupplyAirFlowRateDuringCoolingOperation();
+      resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
+      // resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, "");
       OS_ASSERT(result);
     }
 
     bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(
-      boost::optional<double> designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) {
-      bool result(false);
-      if (designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) {
-        result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation,
-                           designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation.get());
-        boost::optional<std::string> supplyAirFlowRateMethodDuringCoolingOperation("FlowPerCoolingCapacity");
-        result = result && setSupplyAirFlowRateMethodDuringCoolingOperation(supplyAirFlowRateMethodDuringCoolingOperation);
-      } else {
-        resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
-        result = true;
-      }
+      double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) {
+      const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation,
+                                    designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FlowPerCoolingCapacity"));
+      resetSupplyAirFlowRateDuringCoolingOperation();
+      resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
+      resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
+      // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, "");
       OS_ASSERT(result);
     }
 
     bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodDuringHeatingOperation(
-      boost::optional<std::string> supplyAirFlowRateMethodDuringHeatingOperation) {
-      bool result(false);
-      if (supplyAirFlowRateMethodDuringHeatingOperation) {
-        result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation,
-                           supplyAirFlowRateMethodDuringHeatingOperation.get());
-      } else {
-        resetSupplyAirFlowRateMethodDuringHeatingOperation();
-        result = true;
-      }
+      const std::string& supplyAirFlowRateMethodDuringHeatingOperation) {
+      const bool result =
+        setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, supplyAirFlowRateMethodDuringHeatingOperation);
       return result;
     }
 
-    void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateMethodDuringHeatingOperation() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, "");
-      OS_ASSERT(result);
-    }
-
-    bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringHeatingOperation(boost::optional<double> supplyAirFlowRateDuringHeatingOperation) {
-      bool result(false);
-      if (supplyAirFlowRateDuringHeatingOperation) {
-        result =
-          setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, supplyAirFlowRateDuringHeatingOperation.get());
-        boost::optional<std::string> supplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate");
-        result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation);
-      } else {
-        resetSupplyAirFlowRateDuringHeatingOperation();
-        result = true;
-      }
+    bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation) {
+      const bool result =
+        setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, supplyAirFlowRateDuringHeatingOperation);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate"));
+      // resetSupplyAirFlowRateDuringHeatingOperation();
+      resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
+      resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateDuringHeatingOperation() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, "");
       OS_ASSERT(result);
     }
 
     void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateDuringHeatingOperation() {
-      bool result;
-      result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, "Autosize");
-      boost::optional<std::string> supplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate");
-      result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation);
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, "Autosize");
       OS_ASSERT(result);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate"));
+      // resetSupplyAirFlowRateDuringHeatingOperation();
+      resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
+      resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
     }
 
     bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(
-      boost::optional<double> supplyAirFlowRatePerFloorAreaduringHeatingOperation) {
-      bool result(false);
-      if (supplyAirFlowRatePerFloorAreaduringHeatingOperation) {
-        result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation,
-                           supplyAirFlowRatePerFloorAreaduringHeatingOperation.get());
-        boost::optional<std::string> supplyAirFlowRateMethodDuringHeatingOperation("FlowPerFloorArea");
-        result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation);
-      } else {
-        resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
-        result = true;
-      }
+      double supplyAirFlowRatePerFloorAreaDuringHeatingOperation) {
+      const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation,
+                                    supplyAirFlowRatePerFloorAreaDuringHeatingOperation);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerFloorArea"));
+      resetSupplyAirFlowRateDuringHeatingOperation();
+      // resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
+      resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, "");
       OS_ASSERT(result);
     }
 
-    bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(
-      boost::optional<double> fractionofAutosizedDesignHeatingSupplyAirFlowRate) {
-      bool result(false);
-      if (fractionofAutosizedDesignHeatingSupplyAirFlowRate) {
-        result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate,
-                           fractionofAutosizedDesignHeatingSupplyAirFlowRate.get());
-        boost::optional<std::string> supplyAirFlowRateMethodDuringHeatingOperation("FractionOfAutosizedHeatingValue");
-        result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation);
-      } else {
-        resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
-        result = true;
-      }
+    bool
+      AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) {
+      const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate,
+                                    fractionofAutosizedDesignHeatingSupplyAirFlowRate);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FractionOfAutosizedHeatingValue"));
+      resetSupplyAirFlowRateDuringHeatingOperation();
+      resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
+      // resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
+      resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, "");
       OS_ASSERT(result);
     }
 
     bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(
-      boost::optional<double> designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) {
-      bool result(false);
-      if (designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) {
-        result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation,
-                           designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation.get());
-        boost::optional<std::string> supplyAirFlowRateMethodDuringHeatingOperation("FlowPerHeatingCapacity");
-        result = result && setSupplyAirFlowRateMethodDuringHeatingOperation(supplyAirFlowRateMethodDuringHeatingOperation);
-      } else {
-        resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
-        result = true;
-      }
+      double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) {
+      const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation,
+                                    designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation);
+      OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerHeatingCapacity"));
+      resetSupplyAirFlowRateDuringHeatingOperation();
+      resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
+      resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
+      // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
       return result;
     }
 
     void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() {
-      bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, "");
+      const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, "");
       OS_ASSERT(result);
     }
 
@@ -1413,8 +1389,8 @@ namespace model {
     OS_ASSERT(ok);
     ok = setLatentLoadControl("SensibleOnlyLoadControl");
     OS_ASSERT(ok);
-    autosizeSupplyAirFlowRateDuringCoolingOperation();
-    autosizeSupplyAirFlowRateDuringHeatingOperation();
+    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodDuringCoolingOperation("None");
+    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodDuringHeatingOperation("None");
     autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
     setMaximumSupplyAirTemperature(80.0);
     setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(21.0);
@@ -1553,7 +1529,7 @@ namespace model {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplementalHeatingCoil();
   }
 
-  boost::optional<std::string> AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringCoolingOperation() const {
+  std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringCoolingOperation() const {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateMethodDuringCoolingOperation();
   }
 
@@ -1577,7 +1553,7 @@ namespace model {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
   }
 
-  boost::optional<std::string> AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringHeatingOperation() const {
+  std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringHeatingOperation() const {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateMethodDuringHeatingOperation();
   }
 
@@ -1847,23 +1823,10 @@ namespace model {
     getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplementalHeatingCoil();
   }
 
-  bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation) {
-    return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodDuringCoolingOperation(
-      supplyAirFlowRateMethodDuringCoolingOperation);
-  }
-
-  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringCoolingOperation() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFlowRateMethodDuringCoolingOperation();
-  }
-
   bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation) {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateDuringCoolingOperation(supplyAirFlowRateDuringCoolingOperation);
   }
 
-  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringCoolingOperation() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFlowRateDuringCoolingOperation();
-  }
-
   void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateDuringCoolingOperation() {
     getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeSupplyAirFlowRateDuringCoolingOperation();
   }
@@ -1873,46 +1836,21 @@ namespace model {
       supplyAirFlowRatePerFloorAreaDuringCoolingOperation);
   }
 
-  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
-  }
-
   bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate) {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignCoolingSupplyAirFlowRate(
       fractionofAutosizedDesignCoolingSupplyAirFlowRate);
   }
 
-  void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
-  }
-
   bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(
     double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(
       designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation);
   }
 
-  void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
-  }
-
-  bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation) {
-    return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodDuringHeatingOperation(
-      supplyAirFlowRateMethodDuringHeatingOperation);
-  }
-
-  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringHeatingOperation() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFlowRateMethodDuringHeatingOperation();
-  }
-
   bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation) {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateDuringHeatingOperation(supplyAirFlowRateDuringHeatingOperation);
   }
 
-  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringHeatingOperation() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFlowRateDuringHeatingOperation();
-  }
-
   void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateDuringHeatingOperation() {
     getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeSupplyAirFlowRateDuringHeatingOperation();
   }
@@ -1922,29 +1860,17 @@ namespace model {
       supplyAirFlowRatePerFloorAreaduringHeatingOperation);
   }
 
-  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
-  }
-
   bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignHeatingSupplyAirFlowRate(
       fractionofAutosizedDesignHeatingSupplyAirFlowRate);
   }
 
-  void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
-  }
-
   bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(
     double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(
       designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation);
   }
 
-  void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() {
-    getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
-  }
-
   bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(
     const std::string& supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired) {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(
@@ -2124,11 +2050,6 @@ namespace model {
     getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDesignSpecificationMultispeedObject();
   }
 
-  /// @cond
-  AirLoopHVACUnitarySystem::AirLoopHVACUnitarySystem(std::shared_ptr<detail::AirLoopHVACUnitarySystem_Impl> impl)
-    : ZoneHVACComponent(std::move(impl)) {}
-  /// @endcond
-
   boost::optional<double> AirLoopHVACUnitarySystem::autosizedSupplyAirFlowRateDuringCoolingOperation() const {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedSupplyAirFlowRateDuringCoolingOperation();
   }
@@ -2149,5 +2070,94 @@ namespace model {
     return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedDOASDXCoolingCoilLeavingMinimumAirTemperature();
   }
 
+  /// @cond
+  AirLoopHVACUnitarySystem::AirLoopHVACUnitarySystem(std::shared_ptr<detail::AirLoopHVACUnitarySystem_Impl> impl)
+    : ZoneHVACComponent(std::move(impl)) {}
+
+  // DEPRECATED
+  bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation) {
+    DEPRECATED_AT_MSG(3, 7, 0,
+                      "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
+                      "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or "
+                      "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
+    return false;
+  }
+
+  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringCoolingOperation() {
+    DEPRECATED_AT_MSG(3, 7, 0,
+                      "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
+                      "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or "
+                      "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
+  }
+
+  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringCoolingOperation() {
+    DEPRECATED_AT_MSG(3, 7, 0,
+                      "Use setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or "
+                      "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
+  }
+
+  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() {
+    DEPRECATED_AT_MSG(
+      3, 7, 0,
+      "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
+      "setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
+  }
+
+  void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() {
+    DEPRECATED_AT_MSG(
+      3, 7, 0,
+      "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
+      "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
+  }
+
+  void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() {
+    DEPRECATED_AT_MSG(3, 7, 0,
+                      "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
+                      "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, or setFractionofAutosizedDesignCoolingSupplyAirFlowRate instead.");
+  }
+
+  bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation) {
+    DEPRECATED_AT_MSG(3, 7, 0,
+                      "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
+                      "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or "
+                      "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
+    return false;
+  }
+
+  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringHeatingOperation() {
+    DEPRECATED_AT_MSG(3, 7, 0,
+                      "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
+                      "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or "
+                      "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
+  }
+
+  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringHeatingOperation() {
+    DEPRECATED_AT_MSG(3, 7, 0,
+                      "Use setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or "
+                      "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
+  }
+
+  void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() {
+    DEPRECATED_AT_MSG(
+      3, 7, 0,
+      "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
+      "setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
+  }
+
+  void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() {
+    DEPRECATED_AT_MSG(
+      3, 7, 0,
+      "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
+      "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
+  }
+
+  void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() {
+    DEPRECATED_AT_MSG(3, 7, 0,
+                      "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
+                      "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, or setFractionofAutosizedDesignHeatingSupplyAirFlowRate instead.");
+  }
+
+  /// @endcond
+
 }  // namespace model
 }  // namespace openstudio
diff --git a/src/model/AirLoopHVACUnitarySystem.hpp b/src/model/AirLoopHVACUnitarySystem.hpp
index 0233af0dea1..a906a23c165 100644
--- a/src/model/AirLoopHVACUnitarySystem.hpp
+++ b/src/model/AirLoopHVACUnitarySystem.hpp
@@ -9,6 +9,8 @@
 #include "ModelAPI.hpp"
 #include "ZoneHVACComponent.hpp"
 
+#include "../utilities/core/Deprecated.hpp"
+
 namespace openstudio {
 
 namespace model {
@@ -106,7 +108,7 @@ namespace model {
     boost::optional<HVACComponent> supplementalHeatingCoil() const;
 
     /** In EnergyPlus 8.3.0 and above this property maps to the EnergyPlus field "Cooling Supply Air Flow Rate Method" **/
-    boost::optional<std::string> supplyAirFlowRateMethodDuringCoolingOperation() const;
+    std::string supplyAirFlowRateMethodDuringCoolingOperation() const;
 
     /** In EnergyPlus 8.3.0 and above this property maps to the EnergyPlus field "Cooling Supply Air Flow Rate" **/
     boost::optional<double> supplyAirFlowRateDuringCoolingOperation() const;
@@ -123,7 +125,7 @@ namespace model {
     boost::optional<double> designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() const;
 
     /** In EnergyPlus 8.3.0 and above this property maps to the EnergyPlus field "Heating Supply Air Flow Rate Method" **/
-    boost::optional<std::string> supplyAirFlowRateMethodDuringHeatingOperation() const;
+    std::string supplyAirFlowRateMethodDuringHeatingOperation() const;
 
     /** In EnergyPlus 8.3.0 and above this property maps to the EnergyPlus field "Heating Supply Air Flow Rate" **/
     boost::optional<double> supplyAirFlowRateDuringHeatingOperation() const;
@@ -274,49 +276,37 @@ namespace model {
 
     void resetSupplementalHeatingCoil();
 
-    bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation);
-
-    void resetSupplyAirFlowRateMethodDuringCoolingOperation();
+    OS_DEPRECATED(3, 7, 0) bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation);
+    OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRateMethodDuringCoolingOperation();
 
     bool setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation);
-
-    void resetSupplyAirFlowRateDuringCoolingOperation();
-
+    OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRateDuringCoolingOperation();
     void autosizeSupplyAirFlowRateDuringCoolingOperation();
 
     bool setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(double supplyAirFlowRatePerFloorAreaDuringCoolingOperation);
-
-    void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
+    OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
 
     bool setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate);
-
-    void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
+    OS_DEPRECATED(3, 7, 0) void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
 
     bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation);
+    OS_DEPRECATED(3, 7, 0) void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
 
-    void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
-
-    bool setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation);
-
-    void resetSupplyAirFlowRateMethodDuringHeatingOperation();
+    OS_DEPRECATED(3, 7, 0) bool setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation);
+    OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRateMethodDuringHeatingOperation();
 
     bool setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation);
-
-    void resetSupplyAirFlowRateDuringHeatingOperation();
-
+    OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRateDuringHeatingOperation();
     void autosizeSupplyAirFlowRateDuringHeatingOperation();
 
     bool setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(double supplyAirFlowRatePerFloorAreaduringHeatingOperation);
-
-    void resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
+    OS_DEPRECATED(3, 7, 0) void resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
 
     bool setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate);
-
-    void resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
+    OS_DEPRECATED(3, 7, 0) void resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
 
     bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation);
-
-    void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
+    OS_DEPRECATED(3, 7, 0) void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
 
     bool setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(const std::string& supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired);
 
diff --git a/src/model/AirLoopHVACUnitarySystem_Impl.hpp b/src/model/AirLoopHVACUnitarySystem_Impl.hpp
index e571b4a883f..f56ba5209a7 100644
--- a/src/model/AirLoopHVACUnitarySystem_Impl.hpp
+++ b/src/model/AirLoopHVACUnitarySystem_Impl.hpp
@@ -84,12 +84,14 @@ namespace model {
 
       boost::optional<Schedule> supplyAirFanOperatingModeSchedule() const;
 
+      bool hasHeatingCoil() const;  // For speed
       boost::optional<HVACComponent> heatingCoil() const;
 
       double dXHeatingCoilSizingRatio() const;
 
       bool isDXHeatingCoilSizingRatioDefaulted() const;
 
+      bool hasCoolingCoil() const;  // For speed
       boost::optional<HVACComponent> coolingCoil() const;
 
       bool useDOASDXCoolingCoil() const;
@@ -108,7 +110,7 @@ namespace model {
 
       boost::optional<HVACComponent> supplementalHeatingCoil() const;
 
-      boost::optional<std::string> supplyAirFlowRateMethodDuringCoolingOperation() const;
+      std::string supplyAirFlowRateMethodDuringCoolingOperation() const;
 
       boost::optional<double> supplyAirFlowRateDuringCoolingOperation() const;
 
@@ -120,7 +122,7 @@ namespace model {
 
       boost::optional<double> designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() const;
 
-      boost::optional<std::string> supplyAirFlowRateMethodDuringHeatingOperation() const;
+      std::string supplyAirFlowRateMethodDuringHeatingOperation() const;
 
       boost::optional<double> supplyAirFlowRateDuringHeatingOperation() const;
 
@@ -244,7 +246,7 @@ namespace model {
 
       void resetSupplyAirFanOperatingModeSchedule();
 
-      bool setHeatingCoil(const boost::optional<HVACComponent>& heatingCoil);
+      bool setHeatingCoil(const HVACComponent& heatingCoil);
 
       void resetHeatingCoil();
 
@@ -252,7 +254,7 @@ namespace model {
 
       void resetDXHeatingCoilSizingRatio();
 
-      bool setCoolingCoil(const boost::optional<HVACComponent>& coolingCoil);
+      bool setCoolingCoil(const HVACComponent& coolingCoil);
 
       void resetCoolingCoil();
 
@@ -274,49 +276,45 @@ namespace model {
 
       void resetSupplementalHeatingCoil();
 
-      bool setSupplyAirFlowRateMethodDuringCoolingOperation(boost::optional<std::string> supplyAirFlowRateMethodDuringCoolingOperation);
+      bool setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation);
 
-      void resetSupplyAirFlowRateMethodDuringCoolingOperation();
-
-      bool setSupplyAirFlowRateDuringCoolingOperation(boost::optional<double> supplyAirFlowRateDuringCoolingOperation);
+      bool setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation);
 
       void resetSupplyAirFlowRateDuringCoolingOperation();
 
       void autosizeSupplyAirFlowRateDuringCoolingOperation();
 
-      bool setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(boost::optional<double> supplyAirFlowRatePerFloorAreaDuringCoolingOperation);
+      bool setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(double supplyAirFlowRatePerFloorAreaDuringCoolingOperation);
 
       void resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
 
-      bool setFractionofAutosizedDesignCoolingSupplyAirFlowRate(boost::optional<double> fractionofAutosizedDesignCoolingSupplyAirFlowRate);
+      bool setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate);
 
       void resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
 
-      bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(
-        boost::optional<double> designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation);
+      bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation);
 
       void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
 
-      bool setSupplyAirFlowRateMethodDuringHeatingOperation(boost::optional<std::string> supplyAirFlowRateMethodDuringHeatingOperation);
+      bool setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation);
 
       void resetSupplyAirFlowRateMethodDuringHeatingOperation();
 
-      bool setSupplyAirFlowRateDuringHeatingOperation(boost::optional<double> supplyAirFlowRateDuringHeatingOperation);
+      bool setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation);
 
       void resetSupplyAirFlowRateDuringHeatingOperation();
 
       void autosizeSupplyAirFlowRateDuringHeatingOperation();
 
-      bool setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(boost::optional<double> supplyAirFlowRatePerFloorAreaduringHeatingOperation);
+      bool setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(double supplyAirFlowRatePerFloorAreaduringHeatingOperation);
 
       void resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
 
-      bool setFractionofAutosizedDesignHeatingSupplyAirFlowRate(boost::optional<double> fractionofAutosizedDesignHeatingSupplyAirFlowRate);
+      bool setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate);
 
       void resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
 
-      bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(
-        boost::optional<double> designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation);
+      bool setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation);
 
       void resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
 


Test patch:
diff --git a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp
index 2f76c74654e..43f275c1b8f 100644
--- a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp
+++ b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp
@@ -628,92 +628,171 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_cloneAirLoopHVAC_Nodes) {
   EXPECT_EQ(unitary, a.supplyComponents(openstudio::IddObjectType::OS_AirLoopHVAC_UnitarySystem)[0]);
 }
 
-TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOperation) {
+TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOperation_Cooling) {
   // Test for #4695 - AirLoopHVACUnitarySystem: Supply Air Flow Rate Method During <XXX> Operation should be set via related setters/autosize
 
   Model m;
   AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m);
 
-  // we've already autosized in the ctor
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation());
-  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get());
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation());
-  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get());
-
-  // Test reset
-  unitary.resetSupplyAirFlowRateMethodDuringCoolingOperation();
-  unitary.resetSupplyAirFlowRateMethodDuringHeatingOperation();
-  EXPECT_FALSE(unitary.supplyAirFlowRateMethodDuringCoolingOperation());
-  EXPECT_FALSE(unitary.supplyAirFlowRateMethodDuringHeatingOperation());
+  EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringCoolingOperation());
+
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation());
+
+  // Setting a coil changes things
+  CoilCoolingDXSingleSpeed cc(m);
+  EXPECT_TRUE(unitary.setCoolingCoil(cc));
+  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringCoolingOperation());
+  EXPECT_TRUE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation());
+
+  unitary.resetCoolingCoil();
+  EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringCoolingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation());
+  // Put it back
+  EXPECT_TRUE(unitary.setCoolingCoil(cc));
 
   // SupplyAirFlowRate
   EXPECT_TRUE(unitary.setSupplyAirFlowRateDuringCoolingOperation(1.0));
-  EXPECT_TRUE(unitary.setSupplyAirFlowRateDuringHeatingOperation(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation());
-  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get());
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation());
-  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get());
+  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringCoolingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized());
+  ASSERT_TRUE(unitary.supplyAirFlowRateDuringCoolingOperation());
+  EXPECT_EQ(1.0, unitary.supplyAirFlowRateDuringCoolingOperation().get());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation());
 
   // FlowPerFloorArea
   EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(1.0));
-  EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation());
-  EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get());
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation());
-  EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get());
+  EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringCoolingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation());
+  ASSERT_TRUE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation());
+  EXPECT_EQ(1.0, unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation().get());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation());
 
-  // FractionOfAutosizedXXXValue
+  // FractionOfAutosizedCoolingValue
   EXPECT_TRUE(unitary.setFractionofAutosizedDesignCoolingSupplyAirFlowRate(1.0));
-  EXPECT_TRUE(unitary.setFractionofAutosizedDesignHeatingSupplyAirFlowRate(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation());
-  EXPECT_EQ("FractionOfAutosizedCoolingValue", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get());
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation());
-  EXPECT_EQ("FractionOfAutosizedHeatingValue", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get());
+  EXPECT_EQ("FractionOfAutosizedCoolingValue", unitary.supplyAirFlowRateMethodDuringCoolingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation());
+  ASSERT_TRUE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate());
+  EXPECT_EQ(1.0, unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate().get());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation());
 
-  // FlowPerXXXCapacity
+  // FlowPerCoolingCapacity
   EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(1.0));
-  EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringCoolingOperation());
-  EXPECT_EQ("FlowPerCoolingCapacity", unitary.supplyAirFlowRateMethodDuringCoolingOperation().get());
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodDuringHeatingOperation());
-  EXPECT_EQ("FlowPerHeatingCapacity", unitary.supplyAirFlowRateMethodDuringHeatingOperation().get());
+  EXPECT_EQ("FlowPerCoolingCapacity", unitary.supplyAirFlowRateMethodDuringCoolingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringCoolingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringCoolingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaDuringCoolingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignCoolingSupplyAirFlowRate());
+  ASSERT_TRUE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation());
+  EXPECT_EQ(1.0, unitary.designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation().get());
+}
+
+TEST_F(ModelFixture, AirLoopHVACUnitarySystem_SupplyAirFlowRateMethodDuringOperation_Heating) {
+  // Test for #4695 - AirLoopHVACUnitarySystem: Supply Air Flow Rate Method During <XXX> Operation should be set via related setters/autosize
 
-  // When No Cooling or Heating is Required
-  // we've already autosized in the ctor
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired());
-  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get());
+  Model m;
+  AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m);
 
-  // Test reset
-  unitary.resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired();
-  EXPECT_FALSE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired());
+  EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringHeatingOperation());
+
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation());
+
+  // Setting a coil changes things
+  CoilHeatingDXSingleSpeed cc(m);
+  EXPECT_TRUE(unitary.setHeatingCoil(cc));
+  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation());
+  EXPECT_TRUE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation());
+
+  unitary.resetHeatingCoil();
+  EXPECT_EQ("None", unitary.supplyAirFlowRateMethodDuringHeatingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation());
+  // Put it back
+  EXPECT_TRUE(unitary.setHeatingCoil(cc));
 
   // SupplyAirFlowRate
-  EXPECT_TRUE(unitary.setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired());
-  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get());
+  EXPECT_TRUE(unitary.setSupplyAirFlowRateDuringHeatingOperation(1.0));
+  EXPECT_EQ("SupplyAirFlowRate", unitary.supplyAirFlowRateMethodDuringHeatingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized());
+  ASSERT_TRUE(unitary.supplyAirFlowRateDuringHeatingOperation());
+  EXPECT_EQ(1.0, unitary.supplyAirFlowRateDuringHeatingOperation().get());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation());
 
   // FlowPerFloorArea
-  EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired());
-  EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get());
-
-  // FractionOfAutosizedCoolingValue
-  EXPECT_TRUE(unitary.setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired());
-  EXPECT_EQ("FractionOfAutosizedCoolingValue", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get());
+  EXPECT_TRUE(unitary.setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(1.0));
+  EXPECT_EQ("FlowPerFloorArea", unitary.supplyAirFlowRateMethodDuringHeatingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation());
+  ASSERT_TRUE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation());
+  EXPECT_EQ(1.0, unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation().get());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation());
 
   // FractionOfAutosizedHeatingValue
-  EXPECT_TRUE(unitary.setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired());
-  EXPECT_EQ("FractionOfAutosizedHeatingValue", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get());
-
-  // FlowPerCoolingCapacity
-  EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired());
-  EXPECT_EQ("FlowPerCoolingCapacity", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get());
+  EXPECT_TRUE(unitary.setFractionofAutosizedDesignHeatingSupplyAirFlowRate(1.0));
+  EXPECT_EQ("FractionOfAutosizedHeatingValue", unitary.supplyAirFlowRateMethodDuringHeatingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation());
+  ASSERT_TRUE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate());
+  EXPECT_EQ(1.0, unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate().get());
+  EXPECT_FALSE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation());
 
   // FlowPerHeatingCapacity
-  EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(1.0));
-  ASSERT_TRUE(unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired());
-  EXPECT_EQ("FlowPerHeatingCapacity", unitary.supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired().get());
+  EXPECT_TRUE(unitary.setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(1.0));
+  EXPECT_EQ("FlowPerHeatingCapacity", unitary.supplyAirFlowRateMethodDuringHeatingOperation());
+  EXPECT_FALSE(unitary.isSupplyAirFlowRateDuringHeatingOperationAutosized());
+  EXPECT_FALSE(unitary.supplyAirFlowRateDuringHeatingOperation());
+  EXPECT_FALSE(unitary.supplyAirFlowRatePerFloorAreaduringHeatingOperation());
+  EXPECT_FALSE(unitary.fractionofAutosizedDesignHeatingSupplyAirFlowRate());
+  ASSERT_TRUE(unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation());
+  EXPECT_EQ(1.0, unitary.designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation().get());
+}
+
+TEST_F(ModelFixture, AirLoopHVACUnitarySystem_needToRemoveDeprecated) {
+  Model m;
+  AirLoopHVACUnitarySystem unitary = AirLoopHVACUnitarySystem(m);
+
+  EXPECT_NO_THROW(unitary.setSupplyAirFlowRateMethodDuringCoolingOperation(""));
+  EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateMethodDuringCoolingOperation());
+  EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateDuringCoolingOperation());
+  EXPECT_NO_THROW(unitary.resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation());
+  EXPECT_NO_THROW(unitary.resetFractionofAutosizedDesignCoolingSupplyAirFlowRate());
+  EXPECT_NO_THROW(unitary.resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation());
+
+  EXPECT_NO_THROW(unitary.setSupplyAirFlowRateMethodDuringHeatingOperation(""));
+  EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateMethodDuringHeatingOperation());
+  EXPECT_NO_THROW(unitary.resetSupplyAirFlowRateDuringHeatingOperation());
+  EXPECT_NO_THROW(unitary.resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation());
+  EXPECT_NO_THROW(unitary.resetFractionofAutosizedDesignHeatingSupplyAirFlowRate());
+  EXPECT_NO_THROW(unitary.resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation());
 }